@camstack/system 1.2.359 → 1.2.361

package/dist/builtins/local-network/local-network.addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-W_X44h-s.js");
+const require_dist = require("../../dist-Cv1lnnQq.js");
 const require_tls = require("../../tls-CCMX7MjX.js");
 let zod = require("zod");
 let node_os = require("node:os");
@@ -12,24 +12,26 @@ let node_net = require("node:net");
 * The Network page's address book, as pure functions: custom addresses plus
 * the role flags carried by detected and custom addresses alike.
 *
-* ## Storage
+* ## Storage (D734)
 *
-* The role flags keep the keys they always had, so a rolled-back hub reads
-* them with the meaning it knew: `viewerBaseUrls` (viewer, many),
-* `notificationBaseUrl` (notifications, D709), `agentBaseUrl` and
-* `signInBaseUrl` (agents / sign-in, D729 amendment). A single-valued role is
+* One key per role: `appConnectionUrls` (`appConnections`, many),
+* `notificationTapUrl` (`notificationTaps`), `publicEndpointUrl`
+* (`publicEndpoint`) and `internalUrl` (`internal`). A single-valued role is
 * one URL — at most one address carries it, by construction. `''` / `[]` is
 * automatic. The custom addresses are `customAddresses` (url + label).
 *
-* ## Migration in the read path
+* The keys of the earlier role names (`viewerBaseUrls`, `notificationBaseUrl`,
+* `signInBaseUrl`, `agentBaseUrl`) are not read: a value stored under one is
+* ignored, and that role is automatic until the operator flags it again
+* (D734 — one install, re-set by hand, no migration code).
 *
-* Before this, a single-valued flag could name an address that was in no row:
-* the notification links' typed custom address (D709) and the two hub-address
-* overrides (D729 amendment) were free URLs. {@link normalizeAddressBook}
-* turns every such flag into a custom address carrying that role, on every
-* read; the next write persists the result. It is the same rule forever, not
-* a one-off: a flagged detected address that disappears (a DHCP move) shows up
-* as a custom row instead of vanishing while it still wins.
+* ## A flag on an address that is in no row
+*
+* A flagged detected address can disappear (a DHCP move) while it still wins
+* its role. {@link normalizeAddressBook} turns every single-valued flag that
+* names neither a detected address, a custom one nor the app link into a
+* custom address carrying that role, on every read; the next write persists
+* the result — so the address shows as a custom row instead of vanishing.
 */
 var CustomAddressListSchema = zod.z.array(zod.z.object({
 	baseUrl: zod.z.string(),
@@ -37,14 +39,14 @@ var CustomAddressListSchema = zod.z.array(zod.z.object({
 }));
 /** The label a flag promoted to a custom address is given. */
 var PROMOTED_LABEL = {
-	notifications: "Notification links address",
-	agents: "Hub address for agents",
-	signIn: "Sign-in address"
+	notificationTaps: "Notification taps address",
+	internal: "Internal address",
+	publicEndpoint: "Public endpoint"
 };
 var SINGLE_ROLES = [
-	"notifications",
-	"agents",
-	"signIn"
+	"notificationTaps",
+	"internal",
+	"publicEndpoint"
 ];
 function flagOf(value) {
 	return value === "" ? null : value;
@@ -61,10 +63,10 @@ function parseCustomAddresses(raw) {
 */
 function normalizeAddressBook(stored, detectedUrls) {
 	const flags = {
-		viewer: stored.viewerBaseUrls,
-		notifications: flagOf(stored.notificationBaseUrl),
-		agents: flagOf(stored.agentBaseUrl),
-		signIn: flagOf(stored.signInBaseUrl)
+		appConnections: stored.appConnectionUrls,
+		notificationTaps: flagOf(stored.notificationTapUrl),
+		internal: flagOf(stored.internalUrl),
+		publicEndpoint: flagOf(stored.publicEndpointUrl)
 	};
 	const custom = [...parseCustomAddresses(stored.customAddresses)];
 	for (const role of SINGLE_ROLES) {
@@ -85,10 +87,10 @@ function normalizeAddressBook(stored, detectedUrls) {
 function addressBookPatch(state) {
 	return {
 		customAddresses: state.custom,
-		viewerBaseUrls: state.flags.viewer,
-		notificationBaseUrl: state.flags.notifications ?? "",
-		agentBaseUrl: state.flags.agents ?? "",
-		signInBaseUrl: state.flags.signIn ?? ""
+		appConnectionUrls: state.flags.appConnections,
+		notificationTapUrl: state.flags.notificationTaps ?? "",
+		publicEndpointUrl: state.flags.publicEndpoint ?? "",
+		internalUrl: state.flags.internal ?? ""
 	};
 }
 function withCustomAddress(state, entry) {
@@ -104,20 +106,20 @@ function withoutCustomAddress(state, baseUrl) {
 	return {
 		custom: state.custom.filter((c) => c.baseUrl !== baseUrl),
 		flags: {
-			viewer: state.flags.viewer.filter((u) => u !== baseUrl),
-			notifications: clear(state.flags.notifications),
-			agents: clear(state.flags.agents),
-			signIn: clear(state.flags.signIn)
+			appConnections: state.flags.appConnections.filter((u) => u !== baseUrl),
+			notificationTaps: clear(state.flags.notificationTaps),
+			internal: clear(state.flags.internal),
+			publicEndpoint: clear(state.flags.publicEndpoint)
 		}
 	};
 }
 /** Every role back to automatic for `role`. */
 function withRoleAutomatic(state, role) {
-	return role === "viewer" ? {
+	return role === "appConnections" ? {
 		...state,
 		flags: {
 			...state.flags,
-			viewer: []
+			appConnections: []
 		}
 	} : {
 		...state,
@@ -130,24 +132,24 @@ function withRoleAutomatic(state, role) {
 /**
 * Flag or unflag `baseUrl` for `role`. A single-valued role flagged here moves
 * off every other address (it is one URL); unflagging the address that carries
-* it returns the role to automatic. The app link flagged for notifications IS
-* the automatic answer, stored as automatic — one representation. `viewer`
-* toggles inside the set; toggling while automatic starts from the automatic
-* set (`autoViewer`) so the other addresses keep racing.
+* it returns the role to automatic. The app link flagged for notification
+* taps IS the automatic answer, stored as automatic — one representation.
+* `appConnections` toggles inside the set; toggling while automatic starts
+* from the automatic set (`autoApp`) so the other addresses keep racing.
 */
-function withRoleFlag(state, role, baseUrl, enabled, autoViewer) {
-	if (role === "viewer") {
-		const without = (state.flags.viewer.length === 0 ? autoViewer : state.flags.viewer).filter((u) => u !== baseUrl);
-		const viewer = enabled ? [...without, baseUrl] : without;
+function withRoleFlag(state, role, baseUrl, enabled, autoApp) {
+	if (role === "appConnections") {
+		const without = (state.flags.appConnections.length === 0 ? autoApp : state.flags.appConnections).filter((u) => u !== baseUrl);
+		const appConnections = enabled ? [...without, baseUrl] : without;
 		return {
 			...state,
 			flags: {
 				...state.flags,
-				viewer
+				appConnections
 			}
 		};
 	}
-	if (role === "notifications" && require_dist.isAppLinkBase(baseUrl)) return withRoleAutomatic(state, role);
+	if (role === "notificationTaps" && require_dist.isAppLinkBase(baseUrl)) return withRoleAutomatic(state, role);
 	if (enabled) return {
 		...state,
 		flags: {
@@ -160,12 +162,12 @@ function withRoleFlag(state, role, baseUrl, enabled, autoViewer) {
 /** What a row may be flagged with. */
 function eligibleRoles(endpoint) {
 	if (endpoint.kind === "loopback") return [];
-	if (endpoint.kind === "app-link") return ["notifications"];
+	if (endpoint.kind === "app-link") return ["notificationTaps"];
 	return [
-		"viewer",
-		"notifications",
-		"agents",
-		"signIn"
+		"appConnections",
+		"notificationTaps",
+		"internal",
+		"publicEndpoint"
 	];
 }
 /** A custom address as a palette entry (`kind: 'custom'`). */
@@ -182,27 +184,27 @@ function customEndpoint(entry) {
 }
 /**
 * The palette a client races: the detected endpoints plus the custom
-* addresses flagged `viewer` (a detected URL is never listed twice).
+* addresses flagged `appConnections` (a detected URL is never listed twice).
 */
-function withViewerCustomEndpoints(detected, state) {
+function withAppConnectionCustomEndpoints(detected, state) {
 	const known = new Set(detected.map((e) => e.baseUrl));
-	const wanted = new Set(state.flags.viewer);
+	const wanted = new Set(state.flags.appConnections);
 	const extra = state.custom.filter((c) => wanted.has(c.baseUrl) && !known.has(c.baseUrl)).map(customEndpoint);
 	return [...detected, ...extra];
 }
 /** Every role's answer — the resolvers from `@camstack/types`, nothing else. */
-function resolveRoles(state, viewerPalette, httpsPalette) {
-	return require_dist.resolveHubAddressRoles(withViewerCustomEndpoints(viewerPalette, state), httpsPalette, state.flags);
+function resolveRoles(state, appPalette, httpsPalette) {
+	return require_dist.resolveHubAddressRoles(withAppConnectionCustomEndpoints(appPalette, state), httpsPalette, state.flags);
 }
 function flagsOn(state, baseUrl) {
 	const out = [];
-	if (state.flags.viewer.includes(baseUrl)) out.push("viewer");
+	if (state.flags.appConnections.includes(baseUrl)) out.push("appConnections");
 	for (const role of SINGLE_ROLES) if (state.flags[role] === baseUrl) out.push(role);
 	return out;
 }
 function inUseOn(roles, baseUrl) {
 	const out = [];
-	if (roles.viewer.resolved.includes(baseUrl)) out.push("viewer");
+	if (roles.appConnections.resolved.includes(baseUrl)) out.push("appConnections");
 	for (const role of SINGLE_ROLES) if (roles[role].resolved === baseUrl) out.push(role);
 	return out;
 }
@@ -216,7 +218,7 @@ function buildAddressBook(state, inputs) {
 		detected,
 		custom: customUrls.has(endpoint.baseUrl),
 		flags: endpoint.kind === "app-link" ? [] : flagsOn(state, endpoint.baseUrl),
-		inUse: endpoint.kind === "app-link" ? roles.notifications.resolved === "https://camstack.zentik.app" ? ["notifications"] : [] : inUseOn(roles, endpoint.baseUrl),
+		inUse: endpoint.kind === "app-link" ? roles.notificationTaps.resolved === "https://camstack.zentik.app" ? ["notificationTaps"] : [] : inUseOn(roles, endpoint.baseUrl),
 		eligible: eligibleRoles(endpoint)
 	});
 	return {
@@ -421,20 +423,20 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 		super({
 			allowedAddresses: [],
 			bootSeeded: false,
-			notificationBaseUrl: "",
-			viewerBaseUrls: [],
+			notificationTapUrl: "",
+			appConnectionUrls: [],
 			customAddresses: [],
 			httpEnabled: true,
 			httpPort: require_tls.DEFAULT_LAN_HTTP_PORT,
 			localHostname: "",
-			agentBaseUrl: "",
-			signInBaseUrl: ""
+			internalUrl: "",
+			publicEndpointUrl: ""
 		});
 	}
 	/**
-	* The detected palettes, with the mesh reconciled once: `https` (what agents
-	* and sign-in resolve over, and the app link's `hub=`) and `http` (what the
-	* viewer race resolves over, as before).
+	* The detected palettes, with the mesh reconciled once: `https` (what
+	* `internal` and `publicEndpoint` resolve over, and the app link's `hub=`)
+	* and `http` (what the app-connections race resolves over).
 	*/
 	async palettes() {
 		const port = (await this.resolveAdvertisedListenPort(null)).port;
@@ -472,7 +474,7 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 		const detectedUrls = new Set(detected.map((e) => e.baseUrl));
 		const changed = change(this.addressState(detected), {
 			detectedUrls,
-			autoViewer: [...new Set(detected.filter(require_dist.isDefaultViewerEndpoint).map((e) => e.baseUrl))]
+			autoApp: [...new Set(detected.filter(require_dist.isDefaultAppConnectionEndpoint).map((e) => e.baseUrl))]
 		});
 		const after = normalizeAddressBook({
 			...addressBookPatch(changed),
@@ -489,18 +491,18 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 			source: r.source === "flagged" ? "override" : r.source
 		});
 		return {
-			cluster: legacy(roles.agents),
-			browser: legacy(roles.signIn)
+			cluster: legacy(roles.internal),
+			browser: legacy(roles.publicEndpoint)
 		};
 	}
 	/**
 	* Flag / unflag `baseUrl` for `role`, or (`baseUrl: null`) return the role
 	* to automatic. Validated: the address must be a row (detected, custom, or
-	* the app link for notifications), never loopback, and `signIn` on plain
-	* http only when accepted. A refusal stores nothing.
+	* the app link for `notificationTaps`), never loopback, and
+	* `publicEndpoint` on plain http only when accepted. A refusal stores nothing.
 	*/
 	async setRole(role, baseUrl, enabled, acceptInsecureHttp) {
-		if (baseUrl === null || baseUrl.trim() === "" && role !== "viewer") {
+		if (baseUrl === null || baseUrl.trim() === "" && role !== "appConnections") {
 			await this.changeAddressBook((state) => withRoleAutomatic(state, role));
 			this.ctx.logger.info("local-network: address role set to automatic", { meta: { role } });
 			return;
@@ -513,8 +515,8 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 		}
 		await this.changeAddressBook((state, ctx) => {
 			const known = require_dist.isAppLinkBase(target) || ctx.detectedUrls.has(target) || state.custom.some((c) => c.baseUrl === target);
-			if (enabled && !known && role !== "notifications") throw new Error(`${target} is not in the address list — add it as a custom address first.`);
-			return withRoleFlag(state, role, target, enabled, ctx.autoViewer);
+			if (enabled && !known && role !== "notificationTaps") throw new Error(`${target} is not in the address list — add it as a custom address first.`);
+			return withRoleFlag(state, role, target, enabled, ctx.autoApp);
 		});
 		this.ctx.logger.info("local-network: address role set", { meta: {
 			role,
@@ -523,7 +525,7 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 		} });
 	}
 	async notificationEndpointSnapshot() {
-		const resolution = require_dist.resolveNotificationsAddress(this.storedFlags());
+		const resolution = require_dist.resolveNotificationTapAddress(this.storedFlags());
 		const port = (await this.resolveAdvertisedListenPort(null)).port;
 		return {
 			baseUrl: resolution.flagged,
@@ -532,7 +534,7 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 		};
 	}
 	async snapshotViewerEndpoints() {
-		const resolution = require_dist.resolveViewerAddresses(await this.buildAdvertisedEndpoints(false, false, "http", (await this.resolveAdvertisedListenPort(null)).port), this.storedFlags());
+		const resolution = require_dist.resolveAppConnections(await this.buildAdvertisedEndpoints(false, false, "http", (await this.resolveAdvertisedListenPort(null)).port), this.storedFlags());
 		return {
 			baseUrls: resolution.flagged,
 			resolved: resolution.resolved
@@ -540,14 +542,14 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 	}
 	/**
 	* Palette shown to clients: LAN IPv4, stable LAN IPv6, public, mesh, and
-	* the custom addresses flagged `viewer` (`kind: 'custom'`). The viewer
-	* HTTP/WS race is a subset (`selectViewerEndpoints`) — IPv6 stays in this
+	* the custom addresses flagged `appConnections` (`kind: 'custom'`). The app
+	* HTTP/WS race is a subset (`selectAppConnectionEndpoints`) — IPv6 stays in this
 	* list because ICE/WebRTC gathers it regardless.
 	*/
 	async buildAdvertisedEndpoints(includeLoopback, ipv4Only, scheme, httpsPort) {
 		await this.reconcileMeshEndpoint();
 		const detected = this.endpointsNow(includeLoopback, ipv4Only, scheme, httpsPort);
-		return withViewerCustomEndpoints(detected, this.addressState(detected));
+		return withAppConnectionCustomEndpoints(detected, this.addressState(detected));
 	}
 	/** The DETECTED palette from the cached interface/tunnel/mesh state. */
 	endpointsNow(includeLoopback, ipv4Only, scheme, httpsPort) {
@@ -594,22 +596,22 @@ var LocalNetworkAddon = class extends require_dist.BaseAddon {
 			},
 			getNotificationEndpoint: async () => this.notificationEndpointSnapshot(),
 			setNotificationEndpoint: async ({ baseUrl }) => {
-				await this.setRole("notifications", baseUrl, true, false);
+				await this.setRole("notificationTaps", baseUrl, true, false);
 				return this.notificationEndpointSnapshot();
 			},
 			getViewerEndpoints: async () => this.snapshotViewerEndpoints(),
 			setViewerEndpoints: async ({ baseUrls }) => {
-				const viewer = [...new Set(baseUrls.filter((u) => u.length > 0))];
+				const appConnections = [...new Set(baseUrls.filter((u) => u.length > 0))];
 				await this.changeAddressBook((state) => ({
 					...state,
 					flags: {
 						...state.flags,
-						viewer
+						appConnections
 					}
 				}));
-				this.ctx.logger.info("local-network: viewer endpoints set", { meta: {
-					count: viewer.length,
-					auto: viewer.length === 0
+				this.ctx.logger.info("local-network: app connections set", { meta: {
+					count: appConnections.length,
+					auto: appConnections.length === 0
 				} });
 				return this.snapshotViewerEndpoints();
 			},