@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/local-network/local-network.addon.d.ts

@@ -1,295 +1,296 @@
-import { AdvertisedLocalPort, ConnectionEndpoint, LocalInterface, ProviderRegistration, BaseAddon } from '@camstack/types';
-import { CustomAddress } from './address-book.js';
+import type { AdvertisedLocalPort, ConfigUISchema, ConnectionEndpoint, LocalInterface, ProviderRegistration } from "@camstack/types";
+import { BaseAddon } from "@camstack/types";
+import { type CustomAddress } from "./address-book.js";
 /**
- * Cached mesh-reachable endpoint, learned from the `mesh-network`
- * provider via the `MeshNetworkChanged` event-tail + pull-reconcile.
- * `null` when no mesh provider is joined / reachable.
- */
+* Cached mesh-reachable endpoint, learned from the `mesh-network`
+* provider via the `MeshNetworkChanged` event-tail + pull-reconcile.
+* `null` when no mesh provider is joined / reachable.
+*/
 interface MeshEndpointCache {
-    /** Preferred mesh host — MagicDNS name when available, else raw mesh IP. */
-    readonly host: string;
-    /** Hub HTTPS port the mesh endpoint targets. */
-    readonly port: number;
+	/** Preferred mesh host — MagicDNS name when available, else raw mesh IP. */
+	readonly host: string;
+	/** Hub HTTPS port the mesh endpoint targets. */
+	readonly port: number;
 }
 /** Drop rotated IPv6 / dead extras from the persisted allowlist. */
 export declare const ALLOWLIST_RECONCILE_INTERVAL_MS: number;
 /** The three places a hub listen port can be learned, most authoritative first. */
 export interface ListenPortSources {
-    /** `server.port` from the hub's live config section; null when unreadable. */
-    readonly configured: number | null;
-    /** `CAMSTACK_PORT` off the environment; null when unset / unparseable. */
-    readonly env: number | null;
-    /** The port the CALLER passed. A guess about our socket, not a fact. */
-    readonly callerHint: number | null;
+	/** `server.port` from the hub's live config section; null when unreadable. */
+	readonly configured: number | null;
+	/** `CAMSTACK_PORT` off the environment; null when unset / unparseable. */
+	readonly env: number | null;
+	/** The port the CALLER passed. A guess about our socket, not a fact. */
+	readonly callerHint: number | null;
 }
 interface LocalNetworkConfig {
-    /** Empty = "auto" (every non-loopback / non-link-local address
-     *  participates). Non-empty restricts the candidate set to only
-     *  those operator-pinned addresses. */
-    readonly allowedAddresses: readonly string[];
-    /** Sentinel — `true` after the first-boot auto-seed runs. Lets the
-     *  addon distinguish "fresh install, never touched" (false → seed
-     *  with LAN/Wi-Fi addresses) from "operator explicitly cleared the
-     *  allowlist" (true + empty → respect operator's choice). */
-    readonly bootSeeded: boolean;
-    /**
-     * Role flag `notificationTaps` (D709, D734): the ONE address a notification
-     * TAP opens. Empty = automatic (the CamStack app link). Stored VERBATIM
-     * rather than as an index into the candidate list — interfaces come and go,
-     * and an index would silently re-point after a reboot. See `address-book.ts`.
-     */
-    readonly notificationTapUrl: string;
-    /** Role flag `appConnections`: the addresses the apps try. Empty = automatic. */
-    readonly appConnectionUrls: readonly string[];
-    /** Operator-entered custom addresses (`address-book.ts`). Parsed on read. */
-    readonly customAddresses: readonly CustomAddress[];
-    /** LAN HTTP listener. Default true — native apps skip the private cert. */
-    readonly httpEnabled: boolean;
-    /** Dedicated HTTP port. Must not equal the HTTPS listen port. */
-    readonly httpPort: number;
-    /** Operator-declared DNS name advertised instead of the raw LAN IP. Empty = none. */
-    readonly localHostname: string;
-    /**
-     * Role flag `internal`: the ONE address agents and LAN devices download
-     * from. Empty = automatic.
-     */
-    readonly internalUrl: string;
-    /**
-     * Role flag `publicEndpoint`: the ONE address every off-LAN URL is built on
-     * (sign-in, OAuth2, passkeys, notification buttons / media / admin links).
-     * Empty = automatic.
-     */
-    readonly publicEndpointUrl: string;
+	/** Empty = "auto" (every non-loopback / non-link-local address
+	*  participates). Non-empty restricts the candidate set to only
+	*  those operator-pinned addresses. */
+	readonly allowedAddresses: readonly string[];
+	/** Sentinel — `true` after the first-boot auto-seed runs. Lets the
+	*  addon distinguish "fresh install, never touched" (false → seed
+	*  with LAN/Wi-Fi addresses) from "operator explicitly cleared the
+	*  allowlist" (true + empty → respect operator's choice). */
+	readonly bootSeeded: boolean;
+	/**
+	* Role flag `notificationTaps` (D709, D734): the ONE address a notification
+	* TAP opens. Empty = automatic (the CamStack app link). Stored VERBATIM
+	* rather than as an index into the candidate list — interfaces come and go,
+	* and an index would silently re-point after a reboot. See `address-book.ts`.
+	*/
+	readonly notificationTapUrl: string;
+	/** Role flag `appConnections`: the addresses the apps try. Empty = automatic. */
+	readonly appConnectionUrls: readonly string[];
+	/** Operator-entered custom addresses (`address-book.ts`). Parsed on read. */
+	readonly customAddresses: readonly CustomAddress[];
+	/** LAN HTTP listener. Default true — native apps skip the private cert. */
+	readonly httpEnabled: boolean;
+	/** Dedicated HTTP port. Must not equal the HTTPS listen port. */
+	readonly httpPort: number;
+	/** Operator-declared DNS name advertised instead of the raw LAN IP. Empty = none. */
+	readonly localHostname: string;
+	/**
+	* Role flag `internal`: the ONE address agents and LAN devices download
+	* from. Empty = automatic.
+	*/
+	readonly internalUrl: string;
+	/**
+	* Role flag `publicEndpoint`: the ONE address every off-LAN URL is built on
+	* (sign-in, OAuth2, passkeys, notification buttons / media / admin links).
+	* Empty = automatic.
+	*/
+	readonly publicEndpointUrl: string;
 }
 export declare class LocalNetworkAddon extends BaseAddon<LocalNetworkConfig> {
-    private pollTimer;
-    private allowlistTimer;
-    private allowlistReconcilePending;
-    private lastSnapshotKey;
-    /** Optional public hostname tracked from `NetworkTunnelStarted`/
-     *  `Stopped` events on the bus. */
-    private publicHostname;
-    /**
-     * Mesh-reachable endpoint (Tailscale MagicDNS / 100.x), learned from
-     * the `MeshNetworkChanged` event-tail and refreshed by a pull-reconcile
-     * before each `getConnectionEndpoints` build (events are lossy — D8).
-     * `null` when no mesh provider is joined.
-     */
-    private meshEndpoint;
-    constructor();
-    /**
-     * 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).
-     */
-    private palettes;
-    /** The stored address book, normalised against what is detected now. */
-    private addressState;
-    /** The role flags alone — they do not depend on what is detected. */
-    private storedFlags;
-    /** `getAddresses`: the Addresses table and every role's answer. */
-    private addressBook;
-    /**
-     * Apply one change to the address book and persist it, normalised (a flag
-     * naming an address in no row becomes a custom address in the same write).
-     */
-    private changeAddressBook;
-    /** The deprecated `getHubAddresses` shape, from the role resolvers. */
-    private snapshotHubAddresses;
-    /**
-     * 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 `notificationTaps`), never loopback, and
-     * `publicEndpoint` on plain http only when accepted. A refusal stores nothing.
-     */
-    private setRole;
-    private notificationEndpointSnapshot;
-    private snapshotViewerEndpoints;
-    /**
-     * Palette shown to clients: LAN IPv4, stable LAN IPv6, public, mesh, and
-     * 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.
-     */
-    private buildAdvertisedEndpoints;
-    /** The DETECTED palette from the cached interface/tunnel/mesh state. */
-    private endpointsNow;
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected globalSettingsSchema(): import('@camstack/types').ConfigUISchema;
-    protected onConfigChanged(): Promise<void>;
-    protected onShutdown(): Promise<void>;
-    /**
-     * Other hub addons (e.g. cloudflare-tunnel) signal the active public
-     * FQDN by emitting `NetworkTunnelStarted` on the bus — handled in
-     * `onInitialize`. This setter exists for tests + future direct
-     * callers; cleared by passing an empty string.
-     */
-    setPublicHostname(hostname: string): void;
-    /**
-     * Replace the cached mesh endpoint. Set from the `MeshNetworkChanged`
-     * event-tail + the pull-reconcile; exposed for tests + future direct
-     * callers. Pass `null` to clear (mesh left / no provider joined).
-     */
-    setMeshEndpoint(endpoint: MeshEndpointCache | null): void;
-    /**
-     * Refresh the cached mesh endpoint from the authoritative forked
-     * `mesh-network` provider(s). `mesh-network` is a COLLECTION cap on a
-     * forked addon, so the hub builtin can't see it via `ctx.api` /
-     * `getCollectionEntries` — we resolve each provider by addonId through
-     * the hub-side `capabilityRegistry.getProviderByAddon` resolver (the
-     * same mechanism `device-manager` uses for cross-process exporter
-     * contributions). Best-effort: a provider that's absent / errors /
-     * not joined simply contributes nothing.
-     */
-    private reconcileMeshEndpoint;
-    private resolvedHttpPort;
-    private tlsDataDir;
-    private snapshotTls;
-    /**
-     * Hot-swap the HTTPS listener onto the pair now on disk. A failure is not
-     * thrown — the files are already written and the status reports
-     * `restartRequired` from the served-vs-disk fingerprints — but it is logged:
-     * a certificate change that did not reach the listener must say so.
-     */
-    private putCertificateOnListener;
-    /**
-     * Bind or unbind the LAN HTTP sibling from the addon's own settings, and
-     * keep the leaf SAN in sync with `localHostname`. This is the settings
-     * side-effect path — there is no second persist API.
-     */
-    private applyLanAccessFromSettings;
-    /**
-     * The port this hub is actually listening on, plus the provenance of the
-     * number. The boot loader merges the `CAMSTACK_PORT` env override into the
-     * persisted `server` section (`server/backend/src/boot/boot-config.ts`), so
-     * reading that section gives the authoritative live port — no new setting,
-     * and the same source `tailscale-client` already stamps its mesh endpoints
-     * from, so the two cannot drift.
-     */
-    private resolveAdvertisedListenPort;
-    /** `server.port` from the live config section, or null when unreadable. */
-    private readConfiguredPort;
-    private enumerate;
-    /**
-     * Replace rotated IPv6 and drop addresses that no longer exist, without
-     * clearing operator extras that are still live (docker/vpn opt-in).
-     */
-    private persistReconciledAllowlist;
-    private detectChanges;
+	private pollTimer;
+	private allowlistTimer;
+	private allowlistReconcilePending;
+	private lastSnapshotKey;
+	/** Optional public hostname tracked from `NetworkTunnelStarted`/
+	*  `Stopped` events on the bus. */
+	private publicHostname;
+	/**
+	* Mesh-reachable endpoint (Tailscale MagicDNS / 100.x), learned from
+	* the `MeshNetworkChanged` event-tail and refreshed by a pull-reconcile
+	* before each `getConnectionEndpoints` build (events are lossy — D8).
+	* `null` when no mesh provider is joined.
+	*/
+	private meshEndpoint;
+	constructor();
+	/**
+	* 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).
+	*/
+	private palettes;
+	/** The stored address book, normalised against what is detected now. */
+	private addressState;
+	/** The role flags alone — they do not depend on what is detected. */
+	private storedFlags;
+	/** `getAddresses`: the Addresses table and every role's answer. */
+	private addressBook;
+	/**
+	* Apply one change to the address book and persist it, normalised (a flag
+	* naming an address in no row becomes a custom address in the same write).
+	*/
+	private changeAddressBook;
+	/** The deprecated `getHubAddresses` shape, from the role resolvers. */
+	private snapshotHubAddresses;
+	/**
+	* 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 `notificationTaps`), never loopback, and
+	* `publicEndpoint` on plain http only when accepted. A refusal stores nothing.
+	*/
+	private setRole;
+	private notificationEndpointSnapshot;
+	private snapshotViewerEndpoints;
+	/**
+	* Palette shown to clients: LAN IPv4, stable LAN IPv6, public, mesh, and
+	* 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.
+	*/
+	private buildAdvertisedEndpoints;
+	/** The DETECTED palette from the cached interface/tunnel/mesh state. */
+	private endpointsNow;
+	protected onInitialize(): Promise<ProviderRegistration[]>;
+	protected override globalSettingsSchema(): ConfigUISchema;
+	protected override onConfigChanged(): Promise<void>;
+	protected onShutdown(): Promise<void>;
+	/**
+	* Other hub addons (e.g. cloudflare-tunnel) signal the active public
+	* FQDN by emitting `NetworkTunnelStarted` on the bus — handled in
+	* `onInitialize`. This setter exists for tests + future direct
+	* callers; cleared by passing an empty string.
+	*/
+	setPublicHostname(hostname: string): void;
+	/**
+	* Replace the cached mesh endpoint. Set from the `MeshNetworkChanged`
+	* event-tail + the pull-reconcile; exposed for tests + future direct
+	* callers. Pass `null` to clear (mesh left / no provider joined).
+	*/
+	setMeshEndpoint(endpoint: MeshEndpointCache | null): void;
+	/**
+	* Refresh the cached mesh endpoint from the authoritative forked
+	* `mesh-network` provider(s). `mesh-network` is a COLLECTION cap on a
+	* forked addon, so the hub builtin can't see it via `ctx.api` /
+	* `getCollectionEntries` — we resolve each provider by addonId through
+	* the hub-side `capabilityRegistry.getProviderByAddon` resolver (the
+	* same mechanism `device-manager` uses for cross-process exporter
+	* contributions). Best-effort: a provider that's absent / errors /
+	* not joined simply contributes nothing.
+	*/
+	private reconcileMeshEndpoint;
+	private resolvedHttpPort;
+	private tlsDataDir;
+	private snapshotTls;
+	/**
+	* Hot-swap the HTTPS listener onto the pair now on disk. A failure is not
+	* thrown — the files are already written and the status reports
+	* `restartRequired` from the served-vs-disk fingerprints — but it is logged:
+	* a certificate change that did not reach the listener must say so.
+	*/
+	private putCertificateOnListener;
+	/**
+	* Bind or unbind the LAN HTTP sibling from the addon's own settings, and
+	* keep the leaf SAN in sync with `localHostname`. This is the settings
+	* side-effect path — there is no second persist API.
+	*/
+	private applyLanAccessFromSettings;
+	/**
+	* The port this hub is actually listening on, plus the provenance of the
+	* number. The boot loader merges the `CAMSTACK_PORT` env override into the
+	* persisted `server` section (`server/backend/src/boot/boot-config.ts`), so
+	* reading that section gives the authoritative live port — no new setting,
+	* and the same source `tailscale-client` already stamps its mesh endpoints
+	* from, so the two cannot drift.
+	*/
+	private resolveAdvertisedListenPort;
+	/** `server.port` from the live config section, or null when unreadable. */
+	private readConfiguredPort;
+	private enumerate;
+	/**
+	* Replace rotated IPv6 and drop addresses that no longer exist, without
+	* clearing operator extras that are still live (docker/vpn opt-in).
+	*/
+	private persistReconciledAllowlist;
+	private detectChanges;
 }
 /**
- * Pick the port to advertise, and say where it came from.
- *
- * The caller's hint ranks BELOW everything the hub knows about itself and above
- * nothing but the compiled default — it is kept only so a client written
- * against the old echoing contract behaves exactly as it did before, and it is
- * labelled `caller-hint` so that client's successor can refuse to trust it.
- * Values outside the valid port range are dropped rather than advertised: a
- * malformed `server.port` must fall through to the next source, not produce a
- * URL nothing can bind.
- */
+* Pick the port to advertise, and say where it came from.
+*
+* The caller's hint ranks BELOW everything the hub knows about itself and above
+* nothing but the compiled default — it is kept only so a client written
+* against the old echoing contract behaves exactly as it did before, and it is
+* labelled `caller-hint` so that client's successor can refuse to trust it.
+* Values outside the valid port range are dropped rather than advertised: a
+* malformed `server.port` must fall through to the next source, not produce a
+* URL nothing can bind.
+*/
 export declare function resolveAdvertisedPort(sources: ListenPortSources): AdvertisedLocalPort;
 /**
- * Lift `os.networkInterfaces()` into our `LocalInterface[]` shape with
- * kind classification + preferred flag. Pure — takes the raw result so
- * tests can feed synthetic data.
- */
+* Lift `os.networkInterfaces()` into our `LocalInterface[]` shape with
+* kind classification + preferred flag. Pure — takes the raw result so
+* tests can feed synthetic data.
+*/
 interface OsNetworkInterfaceInfo {
-    readonly family: string;
-    readonly address: string;
-    readonly cidr?: string | null;
-    readonly netmask: string;
-    readonly internal: boolean;
-    readonly mac: string;
+	readonly family: string;
+	readonly address: string;
+	readonly cidr?: string | null;
+	readonly netmask: string;
+	readonly internal: boolean;
+	readonly mac: string;
 }
 export declare function enumerateOsInterfaces(ifaces: NodeJS.Dict<readonly OsNetworkInterfaceInfo[]>, ipv6Flags?: ReadonlyMap<string, number>): readonly LocalInterface[];
 /**
- * Filter the interface list by the operator's allowlist. Empty
- * allowlist = no-op (every interface passes); otherwise only entries
- * whose `address` matches an allowlist entry remain. IPv6 matches the
- * allowlisted /64 so a rotated privacy address does not hide the live
- * GUA. Loopback is not an advertised client route and is not forced
- * through.
- */
+* Filter the interface list by the operator's allowlist. Empty
+* allowlist = no-op (every interface passes); otherwise only entries
+* whose `address` matches an allowlist entry remain. IPv6 matches the
+* allowlisted /64 so a rotated privacy address does not hide the live
+* GUA. Loopback is not an advertised client route and is not forced
+* through.
+*/
 export declare function applyAllowlist(interfaces: readonly LocalInterface[], allowed: readonly string[]): readonly LocalInterface[];
 /**
- * Rank interfaces and pick the auto-selected outbound one. See the
- * cap's `getPreferred` doc for the heuristic.
- */
+* Rank interfaces and pick the auto-selected outbound one. See the
+* cap's `getPreferred` doc for the heuristic.
+*/
 export declare function pickPreferred(interfaces: readonly LocalInterface[]): LocalInterface | null;
 /**
- * Build the ordered candidate URL list. Priority schema:
- *   0       — preferred LAN IPv4 (or local hostname)
- *   10+     — other LAN IPv4 and stable LAN IPv6
- *   100     — public tunnel hostname (always HTTPS)
- *   150     — mesh endpoint (Tailscale MagicDNS / 100.x, always HTTPS)
- *   1000    — loopback (last resort)
- *
- * The mesh endpoint ranks just below a true public funnel (a Funnel is
- * reachable by ANY client; the mesh needs the peer on the same tailnet)
- * but above loopback. LAN IPv6 sits in the LAN band with IPv4 so a
- * dual-stack client can win the race on IPv6 when it is faster.
- *
- * `scheme` controls loopback URLs and, when LAN HTTP is off, LAN URLs.
- * When {@link LanHttpAdvertisement} is enabled and listening, LAN (and
- * the local-hostname alias) switch to `http://…:httpPort` so a native
- * client can skip the private certificate. Public tunnel + mesh always
- * emit `https://`. Loopback stays on `scheme`/`port` — it is not a LAN
- * candidate.
- */
+* Build the ordered candidate URL list. Priority schema:
+*   0       — preferred LAN IPv4 (or local hostname)
+*   10+     — other LAN IPv4 and stable LAN IPv6
+*   100     — public tunnel hostname (always HTTPS)
+*   150     — mesh endpoint (Tailscale MagicDNS / 100.x, always HTTPS)
+*   1000    — loopback (last resort)
+*
+* The mesh endpoint ranks just below a true public funnel (a Funnel is
+* reachable by ANY client; the mesh needs the peer on the same tailnet)
+* but above loopback. LAN IPv6 sits in the LAN band with IPv4 so a
+* dual-stack client can win the race on IPv6 when it is faster.
+*
+* `scheme` controls loopback URLs and, when LAN HTTP is off, LAN URLs.
+* When {@link LanHttpAdvertisement} is enabled and listening, LAN (and
+* the local-hostname alias) switch to `http://…:httpPort` so a native
+* client can skip the private certificate. Public tunnel + mesh always
+* emit `https://`. Loopback stays on `scheme`/`port` — it is not a LAN
+* candidate.
+*/
 export interface LanHttpAdvertisement {
-    readonly enabled: boolean;
-    readonly listening: boolean;
-    readonly httpPort: number;
-    readonly httpsPort: number;
-    readonly localHostname: string | null;
+	readonly enabled: boolean;
+	readonly listening: boolean;
+	readonly httpPort: number;
+	readonly httpsPort: number;
+	readonly localHostname: string | null;
 }
 /**
- * The CamStack app link as a palette entry (D709): the one address on the
- * Network page that is not this hub's. Flagging it for notifications (the
- * default) makes viewer taps open the native app, with the hub carried as
- * `hub=`. `kind: 'app-link'` keeps it out of every race and ranking; it is
- * only emitted on `includeAppLink: true`.
- */
+* The CamStack app link as a palette entry (D709): the one address on the
+* Network page that is not this hub's. Flagging it for notifications (the
+* default) makes viewer taps open the native app, with the hub carried as
+* `hub=`. `kind: 'app-link'` keeps it out of every race and ranking; it is
+* only emitted on `includeAppLink: true`.
+*/
 export declare function appLinkEndpoint(): ConnectionEndpoint;
-export declare function buildEndpoints(interfaces: readonly LocalInterface[], port: number, includeLoopback: boolean, ipv4Only: boolean, publicHostname: string, scheme?: 'http' | 'https', meshEndpoint?: MeshEndpointCache | null, lanHttp?: LanHttpAdvertisement | null): ConnectionEndpoint[];
+export declare function buildEndpoints(interfaces: readonly LocalInterface[], port: number, includeLoopback: boolean, ipv4Only: boolean, publicHostname: string, scheme?: "http" | "https", meshEndpoint?: MeshEndpointCache | null, lanHttp?: LanHttpAdvertisement | null): ConnectionEndpoint[];
 /**
- * First-boot heuristic: which addresses should the allowlist start
- * with? Includes LAN + Wi-Fi IPv4 addresses + plausible IPv6:
- *
- *   - **IPv4**: skip link-local (`169.254.*`), keep the rest.
- *   - **IPv6**: skip link-local (`fe80::*`), unspecified, and
- *     multicast. Keep ULAs (`fc00::/7`) and Global Unicast (`2000::/3`).
- *     Privacy-extension temporary addresses are skipped when Linux flags
- *     mark them non-permanent (`plausible === false`).
- *
- * Skips docker/vpn/loopback/other entirely — those stay opt-in.
- */
+* First-boot heuristic: which addresses should the allowlist start
+* with? Includes LAN + Wi-Fi IPv4 addresses + plausible IPv6:
+*
+*   - **IPv4**: skip link-local (`169.254.*`), keep the rest.
+*   - **IPv6**: skip link-local (`fe80::*`), unspecified, and
+*     multicast. Keep ULAs (`fc00::/7`) and Global Unicast (`2000::/3`).
+*     Privacy-extension temporary addresses are skipped when Linux flags
+*     mark them non-permanent (`plausible === false`).
+*
+* Skips docker/vpn/loopback/other entirely — those stay opt-in.
+*/
 export declare function autoSeedAllowlist(interfaces: readonly LocalInterface[]): string[];
 /**
- * Per-interface tooltip text surfaced on the "Unlikely usable" badge.
- * Server-side so the UI doesn't re-derive the rationale (single source
- * of truth). Returns `''` for plausible entries; the addon overlays
- * this on the `LocalInterface.plausibleReason` field.
- */
+* Per-interface tooltip text surfaced on the "Unlikely usable" badge.
+* Server-side so the UI doesn't re-derive the rationale (single source
+* of truth). Returns `''` for plausible entries; the addon overlays
+* this on the `LocalInterface.plausibleReason` field.
+*/
 export declare function explainNonPlausible(input: {
-    readonly kind: LocalInterface['kind'];
-    readonly family: 'IPv4' | 'IPv6';
-    readonly address: string;
-    readonly internal: boolean;
+	readonly kind: LocalInterface["kind"];
+	readonly family: "IPv4" | "IPv6";
+	readonly address: string;
+	readonly internal: boolean;
 }): string;
 /**
- * Per-address gate used by `autoSeedAllowlist`. Exposed for tests so
- * we can pin every classification rule without standing up the addon.
- */
-export declare function isPlausibleAutoSeed(address: string, family: 'IPv4' | 'IPv6'): boolean;
-export declare function classifyKind(name: string, address: string, internal: boolean): LocalInterface['kind'];
+* Per-address gate used by `autoSeedAllowlist`. Exposed for tests so
+* we can pin every classification rule without standing up the addon.
+*/
+export declare function isPlausibleAutoSeed(address: string, family: "IPv4" | "IPv6"): boolean;
+export declare function classifyKind(name: string, address: string, internal: boolean): LocalInterface["kind"];
 /** Convert an IPv4/IPv6 netmask string to its prefix length (CIDR). */
 export declare function prefixLen(netmask: string): number;
 /**
- * Rewrite a persisted allowlist against the live interface set:
- * current auto-seed (LAN/Wi-Fi, stable IPv6) plus still-live operator
- * extras (docker/vpn). Empty stays empty — that is "unrestricted".
- */
+* Rewrite a persisted allowlist against the live interface set:
+* current auto-seed (LAN/Wi-Fi, stable IPv6) plus still-live operator
+* extras (docker/vpn). Empty stays empty — that is "unrestricted".
+*/
 export declare function reconcileAllowlist(current: readonly string[], interfaces: readonly LocalInterface[]): string[];
-export { ipv6Prefix64Key, parseProcIfInet6, shouldAdvertiseIpv6, } from './ipv6-lan.js';
+export { ipv6Prefix64Key, parseProcIfInet6, shouldAdvertiseIpv6 } from "./ipv6-lan.js";

package/dist/builtins/loki-logging/index.d.ts

@@ -1,4 +1,4 @@
-export { LokiLoggingAddon } from './loki-logging.addon.js';
-export { LokiDestination, type LokiConfig, type LokiStatus } from './loki-destination.js';
-export { buildPushBody, formatLokiLine, parseExtraLabels, sanitizeLabelName, toUnixNano, type LokiPushBody, type LokiStream, } from './loki-payload.js';
-export { LokiLoggingAddon as default } from './loki-logging.addon.js';
+export { LokiLoggingAddon } from "./loki-logging.addon.js";
+export { LokiDestination, type LokiConfig, type LokiStatus } from "./loki-destination.js";
+export { buildPushBody, formatLokiLine, parseExtraLabels, sanitizeLabelName, toUnixNano, type LokiPushBody, type LokiStream } from "./loki-payload.js";
+export { LokiLoggingAddon as default } from "./loki-logging.addon.js";