@gryt/core 0.1.0 → 0.3.0

package/README.md

@@ -1,7 +1,23 @@
-# @gryt/core
+<div align="center">
+  <img src="https://raw.githubusercontent.com/Gryt-chat/client/main/public/logo.svg" width="80" alt="Gryt logo" />
+  <h1>@gryt/core</h1>
+  <p>The application logic from <a href="https://github.com/Gryt-chat/gryt">Gryt</a> that the desktop and the phone both run.<br />One implementation of the things they were each doing separately.</p>
+</div>
 
-Gryt's shared application logic. One implementation of the things the desktop
-app and the phone app both do.
+<br />
+
+```sh
+npm install @gryt/core
+```
+
+The desktop app and the mobile app carried a copy each of the same decisions.
+Some were real copies, some were the same idea written twice, and nothing told
+the two apart until somebody diffed them by hand. `report.ts` had the same seven
+exports on both sides and a different `MESSAGE_MAX` on each, 8000 against 4000,
+with nothing recording why.
+
+They run this, not two ports of it. Both apps should pin the same version: a
+shared package on two versions is two implementations again.
 
 ## What goes in here
 
@@ -14,38 +30,42 @@ Two questions, and a module needs both answers to be yes:
 `window` and `localStorage` fail to typecheck rather than working in one app and
 breaking in the other. The second is a judgement call, and the surface guard is
 what stops it drifting: `scripts/check-public-surface.mjs` fails when an export
-is missing *and* when one appears that nobody listed.
-
-## What does not
-
-Anything that needs a platform. Fetching is the clearest case — the desktop and
-the phone reach a server differently, and neither way belongs here — so this
-package decides what a link preview *means* and each app fetches it.
+goes missing **and** when one appears that nobody listed.
+
+## What it is
+
+- **`reports`** — the shape [`Gryt-chat/reports`](https://github.com/Gryt-chat/reports)
+  takes, and how an app fills it in. `Diagnostics` is the union of what each
+  platform can find out, so a renderer sends its Chrome build, a phone sends
+  whether it's a simulator, and a field neither fills can be seen to be dead.
+- **`links`** — which site a URL belongs to, what colour to draw its card, what
+  line to read out of its path, and which of four shapes a preview earns. 73
+  sites, seven of which also read a detail from the path.
+- **`profile`** — the pool of placeholder names a person gets before they pick
+  one. Both apps handed these out and both files said to keep the other in step
+  by hand.
+- **`permissions`** — the channel scope matrix: rules in, grid out, and back.
+  The two apps keyed their cell map differently, a NUL on the desktop and a
+  space on the phone, which is a key one of them could collide on.
+
+## What deliberately isn't
+
+Anything needing a platform. Fetching is the clearest case: the desktop and the
+phone reach a server differently, so this decides what a link preview *means*
+and each app goes and gets it.
 
 Artwork is the other one. A brand logo is a React component on the desktop and
-an SVG path or a favicon on the phone. This package owns the hostnames, the
-colours and the path rules; each app maps a provider `id` to its own icon.
-
-`@gryt/voice` splits web and native behind two entry points because a media
-engine genuinely cannot avoid the platform. This package has no such entry on
-purpose. If one becomes necessary, that is a decision to make out loud.
-
-## What is in it now
+an SVG path or a favicon on the phone, so the package owns the hostnames, the
+colours and the path rules, and each app maps a provider `id` to its own icon.
 
-**Reports** — the shape `Gryt-chat/reports` takes, and how an app fills it in.
-The two apps had a copy each with the same seven exports and different insides.
-Most of the difference was real: a renderer knows its Chrome build, a phone
-knows whether it is a simulator. Some of it was not — `MESSAGE_MAX` was 8000 on
-the desktop and 4000 on the phone, and nothing recorded a reason.
+[`@gryt/voice`](https://github.com/Gryt-chat/voice) splits web and native behind
+two entry points because a media engine can't avoid the platform. This package
+has no such entry, on purpose. If one becomes necessary, that's a decision to
+make out loud rather than by adding `DOM` to the tsconfig.
 
-**Links** — which site a URL belongs to, what colour to draw its card, what line
-to read out of its path, and which of four shapes a preview earns. 73 sites,
-seven of which also read a detail from the path.
-
-## Working on it
+## Checks
 
 ```bash
-npm install
 npm test          # node --test, no runner to install
 npm run typecheck
 npm run build     # tsc to dist/, then rewrite specifiers for ESM
@@ -55,9 +75,29 @@ npm run check-surface
 `prepublishOnly` runs the build, the tests and the surface guard, so a release
 that would have shipped a missing export fails before it leaves.
 
-## Versioning
+## Issues
+
+Please report bugs and request features in the
+[main Gryt repository](https://github.com/Gryt-chat/gryt/issues).
+
+## Sponsors
+
+What sponsoring pays for, the tiers, and everyone who has sponsored:
+[gryt.chat/sponsors](https://gryt.chat/sponsors). To sponsor:
+[GitHub Sponsors](https://github.com/sponsors/Gryt-chat).
+
+The list itself lives in the [Gryt README](https://github.com/Gryt-chat/gryt#sponsors),
+in one place rather than ten, so it cannot fall out of step across repositories.
+
+## License
+
+[AGPL-3.0](https://github.com/Gryt-chat/gryt/blob/main/LICENSE) — Part of [Gryt](https://github.com/Gryt-chat/gryt)
+
+[`@gryt/ui`](https://github.com/Gryt-chat/ui) is the exception in this org, and
+deliberately so: it's generic components with nothing of Gryt in them, and
+copyleft there would rule out most of the people who might use it.
 
-Both apps pin this package. They should pin the *same* version: the point is one
-implementation, and two apps on different versions is two implementations with
-extra steps. `@gryt/voice` is currently `0.4.4` in the client and `^0.3.2` in
-mobile, which is the failure this is meant to avoid.
+This isn't that. It's the decisions the Gryt apps make, which is the product
+rather than scaffolding around it. It's still yours to embed, self-host and
+modify. The licence only bites for running a modified version as a closed
+service.

package/dist/index.d.ts

@@ -14,3 +14,6 @@
 export { buildReport, describeAttached, MESSAGE_MAX, TITLE_MAX, type Diagnostics, type Report, type ReportType, } from "./reports/report.js";
 export { getAccentColor, getLinkProvider, getProviderDetail, hostnameOf, LINK_PROVIDERS, type LinkProvider, } from "./links/providers.js";
 export { describePreviewFailure, extractUrls, getCardSubtitle, getLinkCardLayout, type LinkCardLayout, type LinkPreviewData, } from "./links/preview.js";
+export { normalizeCode, normalizeHost, parseServerInput, type ServerInput, } from "./servers/address.js";
+export { NAME_POOL, pickRandomName } from "./profile/randomName.js";
+export { cellState, CUSTOM_VALUE, describeRules, EVERYONE_VALUE, indexRules, nextCellState, scopeChoiceFromValue, scopeChoiceValue, scopeOptions, scopeSetPayload, withCell, type CellState, type ChannelRule, type RuleEffect, type ScopeChoice, } from "./permissions/channelRules.js";

package/dist/index.js

@@ -14,3 +14,6 @@
 export { buildReport, describeAttached, MESSAGE_MAX, TITLE_MAX, } from "./reports/report.js";
 export { getAccentColor, getLinkProvider, getProviderDetail, hostnameOf, LINK_PROVIDERS, } from "./links/providers.js";
 export { describePreviewFailure, extractUrls, getCardSubtitle, getLinkCardLayout, } from "./links/preview.js";
+export { normalizeCode, normalizeHost, parseServerInput, } from "./servers/address.js";
+export { NAME_POOL, pickRandomName } from "./profile/randomName.js";
+export { cellState, CUSTOM_VALUE, describeRules, EVERYONE_VALUE, indexRules, nextCellState, scopeChoiceFromValue, scopeChoiceValue, scopeOptions, scopeSetPayload, withCell, } from "./permissions/channelRules.js";

package/dist/permissions/channelRules.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The rules on a channel scope, as a matrix and back again.
+ *
+ * Pure and on its own like `serverOrder.ts`, because everything that can go
+ * wrong here is in the mapping between what the server stores and what the grid
+ * shows, and that is worth exercising without React.
+ *
+ * The server stores one row per thing a scope changes. Inherit is the absence
+ * of a row, so the matrix has three states per cell and only two of them are
+ * ever written.
+ *
+ * ## The cell key
+ *
+ * `indexRules` builds one map keyed by role and permission together, and the
+ * separator between them matters. The desktop used a NUL and the phone used a
+ * space, which is two implementations of a key and one of them weaker: a role
+ * id or a permission containing a space would collide. Neither does today, so
+ * nothing was broken, but the two had drifted with nothing to notice it.
+ *
+ * NUL wins, because it cannot appear in either half. It is written as a `\u0000` escape
+ * rather than as a raw byte — the desktop's copy held two literal NULs, which
+ * made git treat the whole file as binary and stop showing diffs for it.
+ */
+export type RuleEffect = "allow" | "deny";
+/** What one cell in the matrix is showing. */
+export type CellState = "inherit" | RuleEffect;
+export interface ChannelRule {
+    roleId: string;
+    permission: string;
+    effect: RuleEffect;
+}
+/** The choice in the channel's dropdown, before any matrix is drawn. */
+export type ScopeChoice = {
+    kind: "everyone";
+} | {
+    kind: "template";
+    templateId: string;
+} | {
+    kind: "custom";
+};
+/** The dropdown value that means "this channel has its own rules". */
+export declare const CUSTOM_VALUE = "custom";
+/**
+ * The dropdown value that means "no rules at all".
+ *
+ * A word rather than an empty string: the Select reads "" as "nothing chosen"
+ * and paints its placeholder over the label, so a channel open to everyone
+ * showed "Select" instead of "Everyone". See [[base-ui-select-empty-value]] —
+ * the Max Bitrate control in the same dialog already used "default" for this.
+ */
+export declare const EVERYONE_VALUE = "everyone";
+/** Look up one cell without scanning the whole list per cell. */
+export declare function indexRules(rules: ChannelRule[]): Map<string, RuleEffect>;
+export declare function cellState(index: Map<string, RuleEffect>, roleId: string, permission: string): CellState;
+/**
+ * The next state when somebody clicks a cell.
+ *
+ * inherit to deny to allow and back to inherit. Deny comes first deliberately:
+ * taking something away is what people open this to do, and it puts the
+ * dangerous state one click from neutral rather than two.
+ */
+export declare function nextCellState(current: CellState): CellState;
+/** Set one cell, dropping the row entirely when it goes back to inherit. */
+export declare function withCell(rules: ChannelRule[], roleId: string, permission: string, state: CellState): ChannelRule[];
+/**
+ * Which dropdown value a channel is showing.
+ *
+ * The server sends the scope id plus whether it is a template. A scope that is
+ * not a template is this channel's own, which is Custom; no scope at all is
+ * Everyone.
+ */
+export declare function scopeChoiceValue(scopeId: string | null, isTemplate: boolean): string;
+/** Turn the dropdown value back into what the server event wants. */
+export declare function scopeChoiceFromValue(value: string): ScopeChoice;
+/**
+ * The payload for `server:channels:scope:set`.
+ *
+ * Custom sends its rules; the other two send none. Templates deliberately do
+ * not carry rules here — editing a template from a channel would change every
+ * other channel using it, which is the opposite of what somebody expects from
+ * a screen titled with one channel's name.
+ */
+export declare function scopeSetPayload(choice: ScopeChoice, rules: ChannelRule[]): {
+    templateId?: string | null;
+    custom?: boolean;
+    rules?: ChannelRule[];
+};
+/**
+ * The dropdown options: Everyone, then each template, then Custom.
+ *
+ * Custom last because it is the escape hatch. Somebody scanning the list should
+ * meet the shared answers first — the whole point of templates is that reaching
+ * for Custom is the uncommon choice.
+ */
+export declare function scopeOptions(templates: {
+    id: string;
+    name: string | null;
+}[]): {
+    label: string;
+    value: string;
+}[];
+/**
+ * A one-line summary of what a set of rules does, for the note under the
+ * dropdown.
+ *
+ * Reading is called out on its own because it is the rule with a different
+ * consequence: a role denied `read_messages` is not shown a locked channel,
+ * it is shown nothing at all, and somebody setting that deserves to be told.
+ */
+export declare function describeRules(rules: ChannelRule[], roleNames: Map<string, string>): string;

package/dist/permissions/channelRules.js

@@ -0,0 +1,140 @@
+/**
+ * The rules on a channel scope, as a matrix and back again.
+ *
+ * Pure and on its own like `serverOrder.ts`, because everything that can go
+ * wrong here is in the mapping between what the server stores and what the grid
+ * shows, and that is worth exercising without React.
+ *
+ * The server stores one row per thing a scope changes. Inherit is the absence
+ * of a row, so the matrix has three states per cell and only two of them are
+ * ever written.
+ *
+ * ## The cell key
+ *
+ * `indexRules` builds one map keyed by role and permission together, and the
+ * separator between them matters. The desktop used a NUL and the phone used a
+ * space, which is two implementations of a key and one of them weaker: a role
+ * id or a permission containing a space would collide. Neither does today, so
+ * nothing was broken, but the two had drifted with nothing to notice it.
+ *
+ * NUL wins, because it cannot appear in either half. It is written as a `\u0000` escape
+ * rather than as a raw byte — the desktop's copy held two literal NULs, which
+ * made git treat the whole file as binary and stop showing diffs for it.
+ */
+/** The dropdown value that means "this channel has its own rules". */
+export const CUSTOM_VALUE = "custom";
+/**
+ * The dropdown value that means "no rules at all".
+ *
+ * A word rather than an empty string: the Select reads "" as "nothing chosen"
+ * and paints its placeholder over the label, so a channel open to everyone
+ * showed "Select" instead of "Everyone". See [[base-ui-select-empty-value]] —
+ * the Max Bitrate control in the same dialog already used "default" for this.
+ */
+export const EVERYONE_VALUE = "everyone";
+/** Look up one cell without scanning the whole list per cell. */
+export function indexRules(rules) {
+    const byCell = new Map();
+    for (const rule of rules)
+        byCell.set(`${rule.roleId}\u0000${rule.permission}`, rule.effect);
+    return byCell;
+}
+export function cellState(index, roleId, permission) {
+    return index.get(`${roleId}\u0000${permission}`) ?? "inherit";
+}
+/**
+ * The next state when somebody clicks a cell.
+ *
+ * inherit to deny to allow and back to inherit. Deny comes first deliberately:
+ * taking something away is what people open this to do, and it puts the
+ * dangerous state one click from neutral rather than two.
+ */
+export function nextCellState(current) {
+    if (current === "inherit")
+        return "deny";
+    if (current === "deny")
+        return "allow";
+    return "inherit";
+}
+/** Set one cell, dropping the row entirely when it goes back to inherit. */
+export function withCell(rules, roleId, permission, state) {
+    const without = rules.filter((r) => !(r.roleId === roleId && r.permission === permission));
+    if (state === "inherit")
+        return without;
+    return [...without, { roleId, permission, effect: state }];
+}
+/**
+ * Which dropdown value a channel is showing.
+ *
+ * The server sends the scope id plus whether it is a template. A scope that is
+ * not a template is this channel's own, which is Custom; no scope at all is
+ * Everyone.
+ */
+export function scopeChoiceValue(scopeId, isTemplate) {
+    if (!scopeId)
+        return EVERYONE_VALUE;
+    return isTemplate ? scopeId : CUSTOM_VALUE;
+}
+/** Turn the dropdown value back into what the server event wants. */
+export function scopeChoiceFromValue(value) {
+    if (value === CUSTOM_VALUE)
+        return { kind: "custom" };
+    if (value === EVERYONE_VALUE || value === "")
+        return { kind: "everyone" };
+    return { kind: "template", templateId: value };
+}
+/**
+ * The payload for `server:channels:scope:set`.
+ *
+ * Custom sends its rules; the other two send none. Templates deliberately do
+ * not carry rules here — editing a template from a channel would change every
+ * other channel using it, which is the opposite of what somebody expects from
+ * a screen titled with one channel's name.
+ */
+export function scopeSetPayload(choice, rules) {
+    if (choice.kind === "custom")
+        return { custom: true, rules };
+    if (choice.kind === "template")
+        return { templateId: choice.templateId };
+    return { templateId: null };
+}
+/**
+ * The dropdown options: Everyone, then each template, then Custom.
+ *
+ * Custom last because it is the escape hatch. Somebody scanning the list should
+ * meet the shared answers first — the whole point of templates is that reaching
+ * for Custom is the uncommon choice.
+ */
+export function scopeOptions(templates) {
+    return [
+        { label: "Everyone", value: EVERYONE_VALUE },
+        ...templates
+            .filter((t) => t.name)
+            .map((t) => ({ label: t.name, value: t.id })),
+        { label: "Custom…", value: CUSTOM_VALUE },
+    ];
+}
+/**
+ * A one-line summary of what a set of rules does, for the note under the
+ * dropdown.
+ *
+ * Reading is called out on its own because it is the rule with a different
+ * consequence: a role denied `read_messages` is not shown a locked channel,
+ * it is shown nothing at all, and somebody setting that deserves to be told.
+ */
+export function describeRules(rules, roleNames) {
+    if (rules.length === 0)
+        return "Everyone on the server can see and use this channel.";
+    const hidden = rules
+        .filter((r) => r.permission === "read_messages" && r.effect === "deny")
+        .map((r) => roleNames.get(r.roleId) ?? r.roleId);
+    const others = rules.filter((r) => r.permission !== "read_messages").length;
+    if (hidden.length === 0) {
+        return `${others} change${others === 1 ? "" : "s"} to what roles can do here.`;
+    }
+    const list = hidden.length === 1
+        ? hidden[0]
+        : `${hidden.slice(0, -1).join(", ")} and ${hidden[hidden.length - 1]}`;
+    const rest = others > 0 ? `, and ${others} other change${others === 1 ? "" : "s"}` : "";
+    return `${list} will not see this channel at all${rest}.`;
+}

package/dist/profile/randomName.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A name for an install or a phone that has not been given one.
+ *
+ * The alternative was "Unknown" on the desktop and "You" on the phone, and it
+ * was wrong twice over on both: a guest arrived on every server under the same
+ * name, and the generated avatar is seeded on the name, so everybody who had
+ * not set one shared a face. A random word fixes both — it is something to be
+ * called, and it is different per install. GRYT-846.
+ *
+ * The list is deliberately dull. These names go in front of strangers on
+ * somebody else's server, they are read aloud in voice chat, and whoever gets
+ * one did not choose it — so nothing here should be a joke that lands badly, a
+ * word that means something else somewhere, or anything a person would mind
+ * being called for the ten seconds before they change it.
+ *
+ * Only nouns, only English, and nothing that reads as a real person's name.
+ * A stranger arriving as "Marcus" looks like a claim about who they are;
+ * "Bandit" looks like what it is, which is a placeholder.
+ */
+/**
+ * Gems, metals, animals, weather, sky, and a few playful roles.
+ *
+ * Long enough that a room of thirty rarely doubles up, which is the whole
+ * reason for the size — two people called Ruby in a member list is exactly the
+ * confusion the old shared placeholder caused.
+ */
+export declare const NAME_POOL: readonly ["Ruby", "Emerald", "Diamond", "Sapphire", "Topaz", "Opal", "Amber", "Jade", "Onyx", "Pearl", "Quartz", "Garnet", "Amethyst", "Turquoise", "Obsidian", "Marble", "Granite", "Flint", "Slate", "Crystal", "Gold", "Silver", "Copper", "Bronze", "Iron", "Steel", "Cobalt", "Pewter", "Platinum", "Titanium", "Brass", "Nickel", "Shark", "Turtle", "Otter", "Falcon", "Heron", "Badger", "Lynx", "Bison", "Walrus", "Puffin", "Osprey", "Marten", "Ibex", "Tapir", "Gecko", "Manta", "Narwhal", "Pelican", "Raven", "Magpie", "Sparrow", "Kestrel", "Weasel", "Beaver", "Moose", "Elk", "Stoat", "Hedgehog", "Mongoose", "Meerkat", "Albatross", "Barnacle", "Urchin", "Cuttlefish", "Seal", "Puma", "Ocelot", "Caribou", "Wombat", "Numbat", "Quokka", "Capybara", "Sheriff", "Bandit", "Captain", "Ranger", "Scout", "Pilot", "Sailor", "Miner", "Baker", "Cooper", "Mason", "Tinker", "Herald", "Envoy", "Courier", "Gardener", "Lookout", "Skipper", "Wrangler", "Drifter", "Comet", "Nebula", "Quasar", "Aurora", "Meteor", "Eclipse", "Zenith", "Thunder", "Cyclone", "Monsoon", "Blizzard", "Drizzle", "Gale", "Frost", "Ember", "Cinder", "Vapour", "Mistral", "Zephyr", "Squall", "Canyon", "Fjord", "Glacier", "Delta", "Mesa", "Tundra", "Prairie", "Dune", "Reef", "Atoll", "Summit", "Ridge", "Hollow", "Meadow", "Thicket", "Bramble", "Harbour", "Lagoon", "Cove", "Cascade", "Cedar", "Juniper", "Willow", "Birch", "Aspen", "Alder", "Hazel", "Bracken", "Clover", "Fennel", "Sorrel", "Nettle", "Thistle", "Heather", "Saffron", "Cardamom", "Chicory", "Marigold"];
+/**
+ * One name from the pool.
+ *
+ * `Math.random` on purpose. This picks something to be called, not a secret —
+ * the identity is a keypair, and the name has never been part of it. Reaching
+ * for the crypto RNG here would suggest otherwise.
+ */
+export declare function pickRandomName(): string;

package/dist/profile/randomName.js

@@ -0,0 +1,68 @@
+/**
+ * A name for an install or a phone that has not been given one.
+ *
+ * The alternative was "Unknown" on the desktop and "You" on the phone, and it
+ * was wrong twice over on both: a guest arrived on every server under the same
+ * name, and the generated avatar is seeded on the name, so everybody who had
+ * not set one shared a face. A random word fixes both — it is something to be
+ * called, and it is different per install. GRYT-846.
+ *
+ * The list is deliberately dull. These names go in front of strangers on
+ * somebody else's server, they are read aloud in voice chat, and whoever gets
+ * one did not choose it — so nothing here should be a joke that lands badly, a
+ * word that means something else somewhere, or anything a person would mind
+ * being called for the ten seconds before they change it.
+ *
+ * Only nouns, only English, and nothing that reads as a real person's name.
+ * A stranger arriving as "Marcus" looks like a claim about who they are;
+ * "Bandit" looks like what it is, which is a placeholder.
+ */
+/**
+ * Gems, metals, animals, weather, sky, and a few playful roles.
+ *
+ * Long enough that a room of thirty rarely doubles up, which is the whole
+ * reason for the size — two people called Ruby in a member list is exactly the
+ * confusion the old shared placeholder caused.
+ */
+export const NAME_POOL = [
+    // Gems and minerals
+    "Ruby", "Emerald", "Diamond", "Sapphire", "Topaz", "Opal", "Amber", "Jade",
+    "Onyx", "Pearl", "Quartz", "Garnet", "Amethyst", "Turquoise", "Obsidian",
+    "Marble", "Granite", "Flint", "Slate", "Crystal",
+    // Metals
+    "Gold", "Silver", "Copper", "Bronze", "Iron", "Steel", "Cobalt", "Pewter",
+    "Platinum", "Titanium", "Brass", "Nickel",
+    // Animals
+    "Shark", "Turtle", "Otter", "Falcon", "Heron", "Badger", "Lynx", "Bison",
+    "Walrus", "Puffin", "Osprey", "Marten", "Ibex", "Tapir", "Gecko", "Manta",
+    "Narwhal", "Pelican", "Raven", "Magpie", "Sparrow", "Kestrel", "Weasel",
+    "Beaver", "Moose", "Elk", "Stoat", "Hedgehog", "Mongoose", "Meerkat",
+    "Albatross", "Barnacle", "Urchin", "Cuttlefish", "Seal", "Puma", "Ocelot",
+    "Caribou", "Wombat", "Numbat", "Quokka", "Capybara",
+    // Roles, playful
+    "Sheriff", "Bandit", "Captain", "Ranger", "Scout", "Pilot", "Sailor",
+    "Miner", "Baker", "Cooper", "Mason", "Tinker", "Herald", "Envoy", "Courier",
+    "Gardener", "Lookout", "Skipper", "Wrangler", "Drifter",
+    // Weather and sky
+    "Comet", "Nebula", "Quasar", "Aurora", "Meteor", "Eclipse", "Zenith",
+    "Thunder", "Cyclone", "Monsoon", "Blizzard", "Drizzle", "Gale", "Frost",
+    "Ember", "Cinder", "Vapour", "Mistral", "Zephyr", "Squall",
+    // Landscape
+    "Canyon", "Fjord", "Glacier", "Delta", "Mesa", "Tundra", "Prairie", "Dune",
+    "Reef", "Atoll", "Summit", "Ridge", "Hollow", "Meadow", "Thicket", "Bramble",
+    "Harbour", "Lagoon", "Cove", "Cascade",
+    // Plants
+    "Cedar", "Juniper", "Willow", "Birch", "Aspen", "Alder", "Hazel", "Bracken",
+    "Clover", "Fennel", "Sorrel", "Nettle", "Thistle", "Heather", "Saffron",
+    "Cardamom", "Chicory", "Marigold",
+];
+/**
+ * One name from the pool.
+ *
+ * `Math.random` on purpose. This picks something to be called, not a secret —
+ * the identity is a keypair, and the name has never been part of it. Reaching
+ * for the crypto RNG here would suggest otherwise.
+ */
+export function pickRandomName() {
+    return NAME_POOL[Math.floor(Math.random() * NAME_POOL.length)];
+}

package/dist/servers/address.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Reading whatever somebody pasted into the join field.
+ *
+ * Both apps had this, byte for byte: `normalizeHost`, `normalizeCode` and all
+ * of `parseServerInput`, down to the comments. The phone said so in its own
+ * header — a copy, because the desktop's `common` package was never published,
+ * written down in GRYT-406 rather than left to be found once the two had
+ * drifted.
+ *
+ * They had not drifted, which is the only comfortable moment to do this. The
+ * two apps talk to the same servers, so an address one reads differently is a
+ * server the other cannot join, and that failure looks like the server being
+ * down rather than like a parser disagreeing.
+ *
+ * What stayed behind is the scheme memory — `schemeFor`, `rememberScheme` and
+ * the rest. Those reach for storage and the two apps store differently, so they
+ * fail the test at the top of this package.
+ */
+export declare function normalizeHost(input: string): string;
+export declare function normalizeCode(input: string): string;
+export interface ServerInput {
+    /** Empty when nothing usable was in the input. */
+    host: string;
+    /** Empty for a plain address, which carries no code. */
+    code: string;
+}
+/**
+ * Three shapes arrive and they are not the same thing: a full invite link
+ * (`https://gryt.chat/invite?host=…&code=…`), a legacy one
+ * (`https://app.gryt.chat/invite/<code>`), and a plain address (`gryt.chat`,
+ * `192.168.1.5:5001`).
+ *
+ * `normalizeHost` on its own is wrong for the first two — it returns the
+ * *link's* host, which is gryt.chat, and joining that instead of the server
+ * named in the query is a confusing failure rather than an obvious one.
+ *
+ * Anything that does not parse as a link falls through to being an address, so
+ * a typo in a URL still gets the address treatment rather than an error about
+ * invite formats.
+ */
+export declare function parseServerInput(input: string, opts?: {
+    defaultLegacyHost?: string;
+}): ServerInput;

package/dist/servers/address.js

@@ -0,0 +1,84 @@
+/**
+ * Reading whatever somebody pasted into the join field.
+ *
+ * Both apps had this, byte for byte: `normalizeHost`, `normalizeCode` and all
+ * of `parseServerInput`, down to the comments. The phone said so in its own
+ * header — a copy, because the desktop's `common` package was never published,
+ * written down in GRYT-406 rather than left to be found once the two had
+ * drifted.
+ *
+ * They had not drifted, which is the only comfortable moment to do this. The
+ * two apps talk to the same servers, so an address one reads differently is a
+ * server the other cannot join, and that failure looks like the server being
+ * down rather than like a parser disagreeing.
+ *
+ * What stayed behind is the scheme memory — `schemeFor`, `rememberScheme` and
+ * the rest. Those reach for storage and the two apps store differently, so they
+ * fail the test at the top of this package.
+ */
+export function normalizeHost(input) {
+    let h = String(input || "").trim();
+    h = h.replace(/^(wss?:\/\/|https?:\/\/)/i, "");
+    h = h.split("/")[0] || "";
+    h = h.replace(/\s+/g, "");
+    return h;
+}
+export function normalizeCode(input) {
+    return String(input || "")
+        .trim()
+        .replace(/\s+/g, "")
+        .toLowerCase();
+}
+/**
+ * The default host for a legacy `/invite/<code>` link.
+ *
+ * Those links carry no host, and the only client ever served from a path like
+ * that is the hosted one.
+ */
+const DEFAULT_LEGACY_HOST = "app.gryt.chat";
+/**
+ * Three shapes arrive and they are not the same thing: a full invite link
+ * (`https://gryt.chat/invite?host=…&code=…`), a legacy one
+ * (`https://app.gryt.chat/invite/<code>`), and a plain address (`gryt.chat`,
+ * `192.168.1.5:5001`).
+ *
+ * `normalizeHost` on its own is wrong for the first two — it returns the
+ * *link's* host, which is gryt.chat, and joining that instead of the server
+ * named in the query is a confusing failure rather than an obvious one.
+ *
+ * Anything that does not parse as a link falls through to being an address, so
+ * a typo in a URL still gets the address treatment rather than an error about
+ * invite formats.
+ */
+export function parseServerInput(input, opts) {
+    const raw = String(input || "").trim();
+    if (!raw)
+        return { host: "", code: "" };
+    const legacyHost = normalizeHost(opts?.defaultLegacyHost || DEFAULT_LEGACY_HOST);
+    // Only something carrying a scheme can be a link. Without this, `gryt.chat`
+    // parses as a URL in some engines with "gryt.chat" as the protocol.
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+        try {
+            const url = new URL(raw);
+            const path = url.pathname || "/";
+            // gryt://invite?host=…&code=… puts "invite" in the authority rather than
+            // the path, because the scheme is not one the URL parser treats as
+            // special. Both spellings mean the same thing.
+            const isInvite = path.startsWith("/invite") || url.hostname === "invite";
+            if (isInvite) {
+                const host = normalizeHost(url.searchParams.get("host") || "");
+                const code = normalizeCode(url.searchParams.get("code") || "");
+                if (host && code)
+                    return { host, code };
+                const parts = path.split("/").filter(Boolean);
+                if (parts[0] === "invite" && parts[1]) {
+                    return { host: legacyHost, code: normalizeCode(parts[1]) };
+                }
+            }
+        }
+        catch {
+            // Not a URL after all. It is still probably an address.
+        }
+    }
+    return { host: normalizeHost(raw), code: "" };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Gryt's shared application logic: one implementation of the things the desktop and mobile apps both do.",
   "license": "AGPL-3.0-only",
   "repository": {