@parity/product-lab 0.0.1-placeholder → 0.1.0

package/core/domain/src/navigation/app-routes.js

@@ -0,0 +1,85 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+function parameter(segment) {
+    const match = /^(?::([A-Za-z_]\w*)|\[([A-Za-z_]\w*)\]|\[\.\.\.([A-Za-z_]\w*)\]|\[\[\.\.\.([A-Za-z_]\w*)\]\])$/.exec(segment);
+    if (!match)
+        return undefined;
+    return { name: (match[1] ?? match[2] ?? match[3] ?? match[4]), rest: !!(match[3] ?? match[4]), optional: !!match[4] };
+}
+export function routeFields(route) {
+    const fields = route.path.split("/").flatMap(segment => {
+        const part = parameter(segment);
+        return part ? [{ name: part.name, field: route.parameters?.[part.name] ?? {}, query: false, required: !part.optional }] : [];
+    });
+    return [...fields, ...Object.entries(route.query ?? {}).map(([name, field]) => ({ name, field, query: true, required: field.required ?? false }))];
+}
+export function validateNavigation(navigation) {
+    if (!["hash", "path"].includes(navigation.mode))
+        throw new Error("Unknown app routing mode");
+    const ids = new Set();
+    for (const route of navigation.routes) {
+        if (!route.id || ids.has(route.id) || !route.label)
+            throw new Error("Routes need unique ids and labels");
+        ids.add(route.id);
+        if (!route.path.startsWith("/") || route.path.startsWith("//") || /[?#\\\s]/.test(route.path))
+            throw new Error("Routes must be root-relative paths without query strings or fragments");
+        const names = new Set();
+        for (const segment of route.path.split("/")) {
+            const part = parameter(segment);
+            if (part) {
+                if (names.has(part.name))
+                    throw new Error("Route parameter names must be unique");
+                names.add(part.name);
+            }
+            else if (/[[\]:]/.test(segment) || /^(\.|%2e){1,2}$/i.test(segment)) {
+                throw new Error(`Unsupported route segment: ${segment}`);
+            }
+        }
+        if (Object.keys(route.parameters ?? {}).some(name => !names.has(name)))
+            throw new Error("Route parameter configuration must match the path");
+    }
+}
+export function buildRouteUrl(appUrl, navigation, routeId, parameters = {}, query = {}) {
+    validateNavigation(navigation);
+    const route = navigation.routes.find(item => item.id === routeId);
+    if (!route)
+        throw new Error("Unknown app route");
+    const segments = route.path.split("/").flatMap(segment => {
+        const part = parameter(segment);
+        if (!part)
+            return [segment];
+        const value = parameters[part.name] ?? route.parameters?.[part.name]?.default ?? "";
+        if (!value.trim()) {
+            if (part.optional)
+                return [];
+            throw new Error(`${route.parameters?.[part.name]?.label ?? part.name} is required`);
+        }
+        const values = part.rest ? value.split("/") : [value];
+        if (values.some(item => !item || item === "." || item === ".."))
+            throw new Error("Route parameters cannot contain empty or dot segments");
+        return values.map(encodeURIComponent);
+    });
+    const search = new URLSearchParams();
+    for (const [name, field] of Object.entries(route.query ?? {})) {
+        const value = query[name] ?? field.default ?? "";
+        if (field.required && !value.trim())
+            throw new Error(`${field.label ?? name} is required`);
+        if (value)
+            search.set(name, value);
+    }
+    const path = (segments.join("/") || "/") + (search.size ? `?${search}` : "");
+    const url = new URL(appUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+        throw new Error("Invalid application URL");
+    if (navigation.mode === "hash")
+        url.hash = path;
+    else {
+        const target = new URL(path, url.origin);
+        if (target.origin !== url.origin)
+            throw new Error("Route must stay on the actor's origin");
+        url.pathname = target.pathname;
+        url.search = target.search;
+        url.hash = "";
+    }
+    return url.href;
+}

package/core/domain/src/navigation/app-url.d.ts

@@ -0,0 +1,9 @@
+/** An app a host can load: a fixed URL, or one built from the host's context (for example its bridge URL). */
+export interface AddressableApp<Context> {
+    readonly id: string;
+    readonly url: string | ((context: Context) => string);
+}
+/** The app's URL in this host context; only http(s) is accepted. */
+export declare function appUrl<Context>(app: AddressableApp<Context>, context: Context): string;
+/** Resolve a root-relative path (with query and fragment) against an app URL. */
+export declare function appUrlAt(base: string, path: string): string;

package/core/domain/src/navigation/app-url.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export function appUrl(app, context) {
+    const url = typeof app.url === "function" ? app.url(context) : app.url;
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol))
+        throw new Error(`App ${app.id} must be served over http(s)`);
+    return parsed.href;
+}
+export function appUrlAt(base, path) {
+    if (!path.startsWith("/") || path.startsWith("//"))
+        throw new Error("App paths must be root-relative");
+    const root = new URL(base);
+    const target = new URL(path, root.origin);
+    if (target.origin !== root.origin)
+        throw new Error("App path must stay on the app's origin");
+    const merged = new URLSearchParams(root.search);
+    for (const [key, value] of target.searchParams)
+        merged.set(key, value);
+    target.search = merged.toString();
+    return target.href;
+}

package/core/domain/src/navigation/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./navigation-request.js";
+export * from "./navigation-resolution.js";
+export * from "./named-destination.js";
+export * from "./navigation-evidence.js";
+export * from "./app-routes.js";
+export * from "./navigation-expectation.js";
+export * from "./app-url.js";

package/core/domain/src/navigation/index.js

@@ -0,0 +1,9 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export * from "./navigation-request.js";
+export * from "./navigation-resolution.js";
+export * from "./named-destination.js";
+export * from "./navigation-evidence.js";
+export * from "./app-routes.js";
+export * from "./navigation-expectation.js";
+export * from "./app-url.js";

package/core/domain/src/navigation/named-destination.d.ts

@@ -0,0 +1,43 @@
+import { type NavigationTarget, type RegisteredApp, type ResolveOptions } from "./navigation-resolution.js";
+/** A name as the environment's name service holds it, at one block. */
+export interface NameRecord {
+    /** The full name, `<label>.<tld>` (for example `example.paseo`). */
+    readonly name: string;
+    /** Where it was read (a block hash). */
+    readonly at: string;
+    /** Root CID of the content the name points at; null when it points at nothing. */
+    readonly cid: string | null;
+}
+/** A lab app, with the content it was deployed as when the lab deployed it. */
+export interface DeployedApp extends RegisteredApp {
+    /** Root CID of the app's deployed bytes; a name resolving to other content does not open it. */
+    readonly cid?: string;
+}
+/** A product destination whose name still has to be looked up. */
+export interface PendingDestination {
+    readonly kind: "name";
+    /** The full name inside the namespace (`.dot` rewritten to `<label>.<namespace>`). */
+    readonly product: string;
+    readonly path: string;
+}
+/**
+ * The name a navigation URL asks the name service about, or its final target
+ * when nothing needs looking up (a web address, an invalid URL, a
+ * host-handled Pocket target).
+ */
+export declare function destinationName(url: string, { namespace }?: ResolveOptions): PendingDestination | NavigationTarget;
+/** The app id a discovered destination gets: the name as a slug (`example.paseo` → `name-example-paseo`). */
+export declare function discoveredAppId(product: string): string;
+/**
+ * Decide a destination from the name service's record (`null`: the service
+ * has no record of the name).
+ *
+ * - No record, or a record pointing at no content: `unregistered`, refused
+ *   (nothing is opened), with the reason.
+ * - A lab app registered under the name: opened, unless the lab deployed it
+ *   and the name now points at other content (then `invalid`: the name no
+ *   longer serves what the lab deployed).
+ * - Content no lab app declares: `app` with `discovered`, so the lab serves
+ *   that content (through its gateway) as a new app for the same actor.
+ */
+export declare function resolveNamedDestination(pending: PendingDestination, record: NameRecord | null, apps: readonly DeployedApp[]): NavigationTarget;

package/core/domain/src/navigation/named-destination.js

@@ -0,0 +1,49 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { parseProductUrl, resolveNavigation } from "./navigation-resolution.js";
+const POCKET_TARGET = /^\/-\/pocket\/(add|open)\/?([?#]|$)/;
+export function destinationName(url, { namespace } = {}) {
+    const destination = parseProductUrl(url);
+    if (!destination)
+        return resolveNavigation(url, [], namespace ? { namespace } : {});
+    const product = namespace && destination.tld === "dot" ? `${destination.label}.${namespace}` : destination.product;
+    if (POCKET_TARGET.test(destination.path))
+        return { kind: "host-target", product, path: destination.path };
+    return { kind: "name", product, path: destination.path };
+}
+export function discoveredAppId(product) {
+    return `name-${product.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`.slice(0, 63).replace(/-+$/, "");
+}
+export function resolveNamedDestination(pending, record, apps) {
+    const { product, path } = pending;
+    if (record && record.name.toLowerCase() !== product)
+        return { kind: "invalid", url: `polkadot://${product}${path}`, reason: `the name service answered for ${record.name}, not ${product}` };
+    if (!record || !record.cid)
+        return {
+            kind: "unregistered",
+            product,
+            path,
+            source: "name-service",
+            reason: record
+                ? `${product} resolves to no content on this environment's name service (not registered, or registered without content)`
+                : `${product} is not registered on this environment's name service`,
+            ...(record ? { resolvedAt: record.at } : {}),
+        };
+    const app = apps.find((candidate) => candidate.product.toLowerCase() === product);
+    if (app?.cid && app.cid !== record.cid)
+        return {
+            kind: "invalid",
+            url: `polkadot://${product}${path}`,
+            reason: `${product} resolves to ${record.cid}, not ${app.cid} that the lab deployed as ${app.id}`,
+        };
+    return {
+        kind: "app",
+        appId: app?.id ?? discoveredAppId(product),
+        product,
+        path,
+        cid: record.cid,
+        resolvedAt: record.at,
+        source: "name-service",
+        ...(app ? {} : { discovered: true }),
+    };
+}

package/core/domain/src/navigation/navigation-evidence.d.ts

@@ -0,0 +1,20 @@
+import type { NavigationTarget } from "./navigation-resolution.js";
+export interface NavigationEvidence {
+    kind: "navigation";
+    actorId: string;
+    fromApp: string;
+    url: string;
+    product: string | null;
+    path: string | null;
+    /** When the host recorded the request (unix ms). */
+    requestedAt: number;
+    target: NavigationTarget;
+    /** `opened`: a new session for the destination app; `focused`: the actor's
+     * existing session; `ignored`: not an app destination (see `target`);
+     * `failed`: resolving succeeded but opening did not (see `error`). */
+    outcome: "opened" | "focused" | "ignored" | "failed";
+    toApp?: string;
+    /** When the bridge finished handling it (unix ms). */
+    handledAt: number;
+    error?: string;
+}

package/core/domain/src/navigation/navigation-evidence.js

@@ -0,0 +1,3 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export {};

package/core/domain/src/navigation/navigation-expectation.d.ts

@@ -0,0 +1,16 @@
+import type { NavigationEvidence } from "./navigation-evidence.js";
+import type { NavigationTarget } from "./navigation-resolution.js";
+export interface ExpectedNavigation {
+    url: string;
+    /** `app <id>`, `unregistered <name>`, `host-target <name>`, `external` or `invalid`. */
+    destination: string;
+    /** `-` for web addresses. */
+    path: string;
+    outcome: "opened" | "focused" | "ignored" | "failed";
+}
+/** How a navigation target reads in a table cell. */
+export declare function describeDestination(target: NavigationTarget): string;
+/** The actor's records matching every expected row in order (a subsequence), or null. */
+export declare function findNavigations(evidence: readonly NavigationEvidence[], actorId: string, expected: readonly ExpectedNavigation[]): NavigationEvidence[] | null;
+/** The actor's recorded requests in one line, for a failure message. */
+export declare function describeNavigationRecords(evidence: readonly NavigationEvidence[], actorId: string): string;

package/core/domain/src/navigation/navigation-expectation.js

@@ -0,0 +1,40 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export function describeDestination(target) {
+    switch (target.kind) {
+        case "app":
+            return `app ${target.appId}`;
+        case "unregistered":
+        case "host-target":
+            return `${target.kind} ${target.product}`;
+        default:
+            return target.kind;
+    }
+}
+function matches(evidence, expected) {
+    return (evidence.url === expected.url &&
+        describeDestination(evidence.target) === expected.destination &&
+        (evidence.path ?? "-") === expected.path &&
+        evidence.outcome === expected.outcome);
+}
+export function findNavigations(evidence, actorId, expected) {
+    const found = [];
+    let next = 0;
+    for (const item of evidence) {
+        if (next === expected.length)
+            break;
+        if (item.actorId === actorId && matches(item, expected[next])) {
+            found.push(item);
+            next++;
+        }
+    }
+    return next === expected.length ? found : null;
+}
+export function describeNavigationRecords(evidence, actorId) {
+    const own = evidence.filter((item) => item.actorId === actorId);
+    if (!own.length)
+        return "no navigation requests were recorded for this actor";
+    return own
+        .map((item) => `${item.url} | ${describeDestination(item.target)} | ${item.path ?? "-"} | ${item.outcome}${item.error ? ` (${item.error})` : ""}`)
+        .join("; ");
+}

package/core/domain/src/navigation/navigation-request.d.ts

@@ -0,0 +1,16 @@
+/** One navigation request a product made through the host. */
+export interface NavigationRequested {
+    /** URL exactly as the host received it from the truAPI core. */
+    url: string;
+    /** DotNS name for a `polkadot://` destination (for example `example.paseo`);
+     * null for web addresses. */
+    product: string | null;
+    /** Root-relative path, query and fragment for a `polkadot://` destination
+     * (at least `/`); null for web addresses. */
+    path: string | null;
+    /** Unix time in milliseconds when the host recorded the request. */
+    at: number;
+}
+/** Build a `NavigationRequested` from a URL a host reported. Throws for a
+ * `polkadot://` URL that names no DotNS product. */
+export declare function navigationRequest(url: string, at: number): NavigationRequested;

package/core/domain/src/navigation/navigation-request.js

@@ -0,0 +1,13 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { parseProductUrl } from "./navigation-resolution.js";
+export function navigationRequest(url, at) {
+    if (typeof url !== "string" || url.length === 0)
+        throw new Error("missing url");
+    if (!Number.isSafeInteger(at) || at < 0)
+        throw new Error("missing or invalid at");
+    const destination = parseProductUrl(url);
+    if (!destination && url.toLowerCase().startsWith("polkadot://"))
+        throw new Error("polkadot:// URL does not name a DotNS product");
+    return { url, product: destination?.product ?? null, path: destination?.path ?? null, at };
+}

package/core/domain/src/navigation/navigation-resolution.d.ts

@@ -0,0 +1,69 @@
+/** DotNS TLDs the truAPI core classifies as product destinations
+ * (host-rust-core `truapi_platform::DOTNS_TLDS`). */
+export declare const DOTNS_TLDS: readonly ["dot", "paseo", "testnet"];
+export interface ProductDestination {
+    product: string;
+    label: string;
+    tld: string;
+    path: string;
+}
+/**
+ * Split a `polkadot://<name>[/path][?query][#fragment]` URL. Returns null for
+ * any other scheme, and for a `polkadot://` URL the core would never produce
+ * (non-DotNS name, port or userinfo, empty labels).
+ */
+export declare function parseProductUrl(url: string): ProductDestination | null;
+/** An app registered in the lab under its DotNS product name. */
+export interface RegisteredApp {
+    id: string;
+    /** DotNS name the host serves it as, `<label>.<namespace>` (the CLI's
+     * `--product-id`), for example `example.paseo`. */
+    product: string;
+}
+/**
+ * Where a destination was found: the lab's own app list (`apps`, the static
+ * map `dev` uses), or the environment's name service (`name-service`: DotNS
+ * on a local fork, in `deployed-local`). See named-destination.ts.
+ */
+export type DestinationSource = "apps" | "name-service";
+export type NavigationTarget = {
+    kind: "app";
+    appId: string;
+    product: string;
+    path: string;
+    /** Set when the name service resolved it: the content the name points at. */
+    cid?: string;
+    /** Where the name service's answer was read (a block hash). */
+    resolvedAt?: string;
+    source?: DestinationSource;
+    /** The name resolved to content no lab app declares; the lab serves that content as a new app. */
+    discovered?: boolean;
+} | {
+    kind: "unregistered";
+    product: string;
+    path: string;
+    reason?: string;
+    resolvedAt?: string;
+    source?: DestinationSource;
+} | {
+    kind: "host-target";
+    product: string;
+    path: string;
+} | {
+    kind: "external";
+    url: string;
+} | {
+    kind: "invalid";
+    url: string;
+    reason: string;
+};
+export interface ResolveOptions {
+    /** Network namespace (`paseo`, `testnet`). When set, a `.dot` name is read
+     * as `<label>.<namespace>`, the rewrite environment-aware hosts apply. */
+    namespace?: string;
+}
+/**
+ * Map a navigation URL to a registered app and root-relative path. The caller
+ * opens that app in the same actor's session.
+ */
+export declare function resolveNavigation(url: string, apps: readonly RegisteredApp[], { namespace }?: ResolveOptions): NavigationTarget;

package/core/domain/src/navigation/navigation-resolution.js

@@ -0,0 +1,37 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export const DOTNS_TLDS = ["dot", "paseo", "testnet"];
+export function parseProductUrl(url) {
+    const scheme = "polkadot://";
+    if (url.slice(0, scheme.length).toLowerCase() !== scheme)
+        return null;
+    const rest = url.slice(scheme.length);
+    const end = rest.search(/[/?#]/);
+    const host = (end === -1 ? rest : rest.slice(0, end)).toLowerCase().replace(/\.$/, "");
+    const suffix = end === -1 ? "" : rest.slice(end);
+    if (!/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(host))
+        return null;
+    const dot = host.lastIndexOf(".");
+    const tld = host.slice(dot + 1);
+    if (!DOTNS_TLDS.includes(tld))
+        return null;
+    const path = suffix.startsWith("/") ? suffix : `/${suffix}`;
+    return { product: host, label: host.slice(0, dot), tld, path };
+}
+const POCKET_TARGET = /^\/-\/pocket\/(add|open)\/?([?#]|$)/;
+export function resolveNavigation(url, apps, { namespace } = {}) {
+    const destination = parseProductUrl(url);
+    if (!destination) {
+        if (url.toLowerCase().startsWith("polkadot://"))
+            return { kind: "invalid", url, reason: "polkadot:// URL does not name a DotNS product" };
+        if (/^https?:\/\//i.test(url))
+            return { kind: "external", url };
+        return { kind: "invalid", url, reason: "not a polkadot:// or http(s) URL" };
+    }
+    const product = namespace && destination.tld === "dot" ? `${destination.label}.${namespace}` : destination.product;
+    const { path } = destination;
+    if (POCKET_TARGET.test(path))
+        return { kind: "host-target", product, path };
+    const app = apps.find((candidate) => candidate.product.toLowerCase() === product);
+    return app ? { kind: "app", appId: app.id, product, path } : { kind: "unregistered", product, path };
+}

package/core/domain/src/network/endpoint-locality.d.ts

@@ -0,0 +1,14 @@
+import { type LocatedEndpoint } from "./mixed-endpoints-error.js";
+export { MixedEndpointsError, type LocatedEndpoint } from "./mixed-endpoints-error.js";
+/** The endpoints of an environment or a routing, split by where they are. Immutable. */
+export declare class EndpointLocality {
+    readonly loopback: readonly LocatedEndpoint[];
+    readonly remote: readonly LocatedEndpoint[];
+    private constructor();
+    /** Endpoints by id (`{ people: "ws://127.0.0.1:9944" }`). */
+    static of(endpoints: Readonly<Record<string, string>> | readonly LocatedEndpoint[]): EndpointLocality;
+    /** `loopback` (all on this machine), `public` (all off it), `mixed`, or `empty`. */
+    get kind(): "loopback" | "public" | "mixed" | "empty";
+    /** Throw a `MixedEndpointsError` naming `owner` when the endpoints are mixed. */
+    assertNotMixed(owner: string): void;
+}

package/core/domain/src/network/endpoint-locality.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { LoopbackUrl } from "./loopback-url.js";
+import { MixedEndpointsError } from "./mixed-endpoints-error.js";
+export { MixedEndpointsError } from "./mixed-endpoints-error.js";
+function local(url) {
+    let hostname;
+    try {
+        hostname = new URL(url).hostname;
+    }
+    catch {
+        return false;
+    }
+    return LoopbackUrl.isLoopbackHost(hostname) || hostname.toLowerCase().endsWith(".localhost");
+}
+export class EndpointLocality {
+    loopback;
+    remote;
+    constructor(loopback, remote) {
+        this.loopback = Object.freeze(loopback);
+        this.remote = Object.freeze(remote);
+        Object.freeze(this);
+    }
+    static of(endpoints) {
+        const items = Array.isArray(endpoints) ? [...endpoints] : Object.entries(endpoints).map(([id, url]) => ({ id, url }));
+        return new EndpointLocality(items.filter((item) => local(item.url)), items.filter((item) => !local(item.url)));
+    }
+    get kind() {
+        if (this.loopback.length && this.remote.length)
+            return "mixed";
+        if (this.remote.length)
+            return "public";
+        return this.loopback.length ? "loopback" : "empty";
+    }
+    assertNotMixed(owner) {
+        if (this.kind === "mixed")
+            throw new MixedEndpointsError(owner, this.loopback, this.remote);
+    }
+}

package/core/domain/src/network/environment-endpoints.d.ts

@@ -0,0 +1,36 @@
+import { CapabilityPolicy } from "../lab/capability-policy.js";
+import type { Capability } from "../lab/capability.js";
+export interface ChainEndpoint {
+    ws: string;
+    http: string;
+    rpcPort: number;
+    p2pPort?: number;
+}
+/** Endpoints by chain id and service, as topologies and adapters record them (plain data, serialised in run manifests). */
+export interface EndpointMap<Chain extends string = string> {
+    chains: Partial<Record<Chain, ChainEndpoint>>;
+    services: {
+        identityBackend?: string;
+        ethRpc?: string;
+    };
+}
+export declare class EnvironmentEndpoints<Chain extends string = string> {
+    #private;
+    readonly endpoints: EndpointMap<Chain>;
+    constructor(source: {
+        capabilities: Readonly<Record<Capability, boolean>> | CapabilityPolicy;
+        endpoints: EndpointMap<Chain>;
+        /** Why a capability is absent, when the source can say (ignored for a policy, which carries its reasons). */
+        reason?: (capability: Capability) => string | undefined;
+    });
+    get capabilities(): Readonly<Record<Capability, boolean>>;
+    has(capability: Capability): boolean;
+    /** Substrate RPC endpoint of a chain. */
+    chain(id: Chain): ChainEndpoint;
+    /** eth-rpc URL; only with the `evm` capability. */
+    evm(): string;
+    /** Bulletin RPC (store, `bitswap_v1_get` retrieval); only with `bulletin`. */
+    bulletin(): ChainEndpoint;
+    /** People RPC serving `statement_*`; only with `statementStore`. */
+    statementStore(): ChainEndpoint;
+}

package/core/domain/src/network/environment-endpoints.js

@@ -0,0 +1,49 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { CapabilityPolicy } from "../lab/capability-policy.js";
+import { MissingCapabilityError } from "../shared/missing-capability-error.js";
+const BULLETIN = "bulletin";
+const STATEMENT_STORE = "people";
+export class EnvironmentEndpoints {
+    #policy;
+    endpoints;
+    constructor(source) {
+        this.#policy =
+            source.capabilities instanceof CapabilityPolicy
+                ? source.capabilities
+                : CapabilityPolicy.fromRecord(source.capabilities, { local: true, ...(source.reason ? { reason: source.reason } : {}) });
+        this.endpoints = source.endpoints;
+        Object.freeze(this);
+    }
+    get capabilities() {
+        return this.#policy.capabilities;
+    }
+    has(capability) {
+        return this.#policy.has(capability);
+    }
+    chain(id) {
+        const endpoint = this.endpoints.chains[id];
+        if (!endpoint)
+            throw new MissingCapabilityError(`${id} chain`);
+        return endpoint;
+    }
+    evm() {
+        this.#need("evm");
+        const url = this.endpoints.services.ethRpc;
+        if (!url)
+            throw new MissingCapabilityError("eth-rpc endpoint");
+        return url;
+    }
+    bulletin() {
+        this.#need("bulletin");
+        return this.chain(BULLETIN);
+    }
+    statementStore() {
+        this.#need("statementStore");
+        return this.chain(STATEMENT_STORE);
+    }
+    #need(capability) {
+        if (!this.#policy.has(capability))
+            throw new MissingCapabilityError(`${capability} capability`, this.#policy.reason(capability));
+    }
+}