@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.0

package/dist/tooling/cli/development/target-lock.js

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+import { mkdir, rmdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { acquireDevelopmentLease, DevelopmentLeaseError } from './lease.js';
+export class DevelopmentTargetLockError extends Error {
+    code;
+    name = 'DevelopmentTargetLockError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+/** Exclude local sessions targeting one installed Domain across separate checkouts. */
+export async function acquireDevelopmentTargetLock(input, dependencies = {}) {
+    const coordinate = `${input.issuer}#${input.origin}`;
+    const root = dependencies.root ?? join(tmpdir(), 'astrale-domain-development-targets');
+    const key = createHash('sha256')
+        .update(input.issuer)
+        .update('\0')
+        .update(input.origin)
+        .digest('hex');
+    const directory = join(root, key);
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    let lease;
+    try {
+        lease = await acquireDevelopmentLease({
+            directory,
+            coordinate,
+            ...(dependencies.pid === undefined ? {} : { pid: dependencies.pid }),
+            ...(dependencies.sessionId === undefined ? {} : { sessionId: dependencies.sessionId }),
+            ...(dependencies.processAlive === undefined
+                ? {}
+                : { processAlive: dependencies.processAlive }),
+        });
+    }
+    catch (cause) {
+        if (cause instanceof DevelopmentLeaseError) {
+            throw new DevelopmentTargetLockError('DEVELOPMENT_TARGET_LOCKED', cause.message, { cause });
+        }
+        throw cause;
+    }
+    return Object.freeze({
+        ...lease,
+        async release() {
+            try {
+                await lease.release();
+            }
+            catch (cause) {
+                if (cause instanceof DevelopmentLeaseError) {
+                    throw new DevelopmentTargetLockError('DEVELOPMENT_TARGET_LOCK_LOST', cause.message, {
+                        cause,
+                    });
+                }
+                throw cause;
+            }
+            await rmdir(directory).catch(ignoreNonEmpty);
+            await rmdir(root).catch(ignoreNonEmpty);
+        },
+    });
+}
+function ignoreNonEmpty(cause) {
+    const code = cause !== null && typeof cause === 'object' && 'code' in cause
+        ? String(Reflect.get(cause, 'code'))
+        : undefined;
+    if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(code ?? ''))
+        throw cause;
+}

package/dist/tooling/cli/development/view.d.ts

@@ -0,0 +1,28 @@
+import type { Release } from '../../../deployment/release/index.js';
+import type { AstraleProcessResult } from '../astrale/process.js';
+export interface DevelopmentViewDependencies {
+    run(input: {
+        readonly executable: string;
+        readonly args: readonly string[];
+        readonly projectDir: string;
+        readonly signal: AbortSignal;
+        readonly timeoutMs: number;
+    }): Promise<AstraleProcessResult>;
+}
+/** Keep one browser tab alive across successful remote deployments. */
+export declare class DevelopmentView {
+    #private;
+    constructor(input: {
+        readonly executable: string;
+        readonly projectDir: string;
+        readonly instance: string;
+        readonly identity?: string;
+        readonly credential?: string;
+        readonly dependencies?: DevelopmentViewDependencies;
+    });
+    /** Require in-place refresh before publishing anything that depends on this CLI feature. */
+    prepare(signal: AbortSignal): Promise<void>;
+    /** Called after each committed deployment; the development loop owns candidate deduplication. */
+    refresh(release: Release, signal: AbortSignal): Promise<string | undefined>;
+    close(signal: AbortSignal): Promise<void>;
+}

package/dist/tooling/cli/development/view.js

@@ -0,0 +1,151 @@
+import { astraleAuthorityArguments } from '../astrale/authority.js';
+import { runAstrale } from '../astrale/process.js';
+/** Keep one browser tab alive across successful remote deployments. */
+export class DevelopmentView {
+    #executable;
+    #projectDir;
+    #instance;
+    #authority;
+    #dependencies;
+    #current;
+    #prepared = false;
+    constructor(input) {
+        this.#executable = input.executable;
+        this.#projectDir = input.projectDir;
+        this.#instance = input.instance;
+        this.#authority = astraleAuthorityArguments({
+            ...(input.identity === undefined ? {} : { identity: input.identity }),
+            ...(input.credential === undefined ? {} : { credential: input.credential }),
+        });
+        this.#dependencies = input.dependencies ?? { run: runAstrale };
+    }
+    /** Require in-place refresh before publishing anything that depends on this CLI feature. */
+    async prepare(signal) {
+        if (this.#prepared)
+            return;
+        const result = await this.#dependencies.run({
+            executable: this.#executable,
+            projectDir: this.#projectDir,
+            signal,
+            timeoutMs: 10_000,
+            args: ['view', '--help'],
+        });
+        if (result.code !== 0 || !result.stdout.includes('--refresh <id>')) {
+            throw new Error('This Astrale CLI cannot refresh development Views. Run astrale update before pnpm dev.');
+        }
+        this.#prepared = true;
+    }
+    /** Called after each committed deployment; the development loop owns candidate deduplication. */
+    async refresh(release, signal) {
+        const frontend = release.build.frontend;
+        if (frontend === undefined) {
+            await this.close(AbortSignal.timeout(30_000));
+            return undefined;
+        }
+        const path = `/:${frontend.entrypoint.origin}:view.${frontend.entrypoint.name}`;
+        const previous = this.#current;
+        if (previous?.path === path) {
+            const refreshed = await this.#dependencies.run({
+                executable: this.#executable,
+                projectDir: this.#projectDir,
+                signal,
+                timeoutMs: 60_000,
+                args: ['--ci', '--no-prompt', 'view', '--refresh', previous.id, '--json'],
+            });
+            if (refreshed.code !== 0)
+                throw new Error('Astrale CLI could not refresh the development View.');
+            return previous.pageUrl;
+        }
+        const next = await this.#open(path, signal);
+        if (previous !== undefined) {
+            try {
+                await this.#close(previous.id, AbortSignal.timeout(30_000));
+            }
+            catch (cause) {
+                try {
+                    await this.#close(next.id, AbortSignal.timeout(30_000));
+                }
+                catch (rollback) {
+                    throw new AggregateError([cause, rollback], 'Astrale View replacement and rollback cleanup failed.');
+                }
+                throw cause;
+            }
+        }
+        this.#current = next;
+        return next.pageUrl;
+    }
+    async close(signal) {
+        const current = this.#current;
+        if (current === undefined)
+            return;
+        await this.#close(current.id, signal);
+        if (this.#current === current) {
+            this.#current = undefined;
+        }
+    }
+    async #open(path, signal) {
+        const result = await this.#dependencies.run({
+            executable: this.#executable,
+            projectDir: this.#projectDir,
+            signal,
+            timeoutMs: 60_000,
+            args: [
+                '--ci',
+                '--no-prompt',
+                'view',
+                path,
+                '--browser',
+                '--instance',
+                this.#instance,
+                '--json',
+                ...this.#authority,
+            ],
+        });
+        if (result.code !== 0)
+            throw new Error('Astrale CLI could not open the development View.');
+        return { ...decodeOpenedView(result.stdout), path };
+    }
+    async #close(id, signal) {
+        const result = await this.#dependencies.run({
+            executable: this.#executable,
+            projectDir: this.#projectDir,
+            signal,
+            timeoutMs: 30_000,
+            args: ['--ci', '--no-prompt', 'view', '--close', id, '--json'],
+        });
+        if (result.code !== 0)
+            throw new Error('Astrale CLI could not close the development View.');
+    }
+}
+function decodeOpenedView(input) {
+    let value;
+    try {
+        value = JSON.parse(input);
+    }
+    catch (cause) {
+        throw new TypeError('Astrale View output is invalid.', { cause });
+    }
+    const session = record(value) ? value.session : undefined;
+    const id = record(session) ? session.id : undefined;
+    const pageUrl = record(session) ? session.pageUrl : undefined;
+    if (typeof id !== 'string' || id.length === 0 || !webUrl(pageUrl)) {
+        throw new TypeError('Astrale View output is invalid.');
+    }
+    return Object.freeze({ id, pageUrl });
+}
+function webUrl(input) {
+    if (typeof input !== 'string' || input.length === 0 || input.length > 2_048)
+        return false;
+    try {
+        const value = new URL(input);
+        return ((value.protocol === 'http:' || value.protocol === 'https:') &&
+            value.username === '' &&
+            value.password === '');
+    }
+    catch {
+        return false;
+    }
+}
+function record(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}

package/dist/tooling/cli/environment-release.d.ts

@@ -0,0 +1,21 @@
+import type { Adapter, InstallationTarget, ReadyDeployResult } from '../../deployment/adapter/index.js';
+import type { InstallationEvidence } from './installation/index.js';
+import { writeDeploymentEvidence } from './evidence.js';
+import { reconcileInstallation } from './installation/index.js';
+export interface EnvironmentReleaseDependencies {
+    readonly writeEvidence: typeof writeDeploymentEvidence;
+    readonly reconcileInstallation: typeof reconcileInstallation;
+}
+/** Retain verified provider evidence and reconcile one optional durable Kernel installation. */
+export declare function reconcileEnvironmentRelease(input: {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly adapter: Adapter<object>;
+    readonly deployment: ReadyDeployResult;
+    readonly installation?: InstallationTarget;
+    readonly deployOnly: boolean;
+    readonly identity?: string;
+    readonly credential?: string;
+    readonly installationExecutable?: string;
+    readonly signal: AbortSignal;
+}, dependencies?: EnvironmentReleaseDependencies): Promise<InstallationEvidence | undefined>;

package/dist/tooling/cli/environment-release.js

@@ -0,0 +1,46 @@
+import { writeDeploymentEvidence } from './evidence.js';
+import { reconcileInstallation } from './installation/index.js';
+/** Retain verified provider evidence and reconcile one optional durable Kernel installation. */
+export async function reconcileEnvironmentRelease(input, dependencies = {
+    writeEvidence: writeDeploymentEvidence,
+    reconcileInstallation,
+}) {
+    try {
+        await dependencies.writeEvidence({
+            projectDir: input.projectDir,
+            environment: input.environment,
+            adapter: input.adapter,
+            deployment: input.deployment,
+        });
+    }
+    catch (cause) {
+        throw new TypeError(`Domain ${input.deployment.release.publication.origin} remains deployed, but its local evidence could not be saved. Kernel installation was not attempted.`, { cause });
+    }
+    if (input.installation === undefined || input.deployOnly)
+        return undefined;
+    if (input.installationExecutable === undefined) {
+        throw new TypeError('A compatible Astrale CLI must be pinned before deploying an installed Environment.');
+    }
+    const installation = await dependencies.reconcileInstallation({
+        projectDir: input.projectDir,
+        target: input.installation,
+        executable: input.installationExecutable,
+        ...(input.identity === undefined ? {} : { identity: input.identity }),
+        ...(input.credential === undefined ? {} : { credential: input.credential }),
+        release: input.deployment.release,
+        signal: input.signal,
+    });
+    try {
+        await dependencies.writeEvidence({
+            projectDir: input.projectDir,
+            environment: input.environment,
+            adapter: input.adapter,
+            deployment: input.deployment,
+            installation,
+        });
+    }
+    catch (cause) {
+        throw new TypeError(`Domain ${installation.origin} remains installed on ${installation.instance}, but its local evidence could not be saved. The installation was not rolled back.`, { cause });
+    }
+    return installation;
+}

package/dist/tooling/cli/evidence.d.ts

@@ -0,0 +1,11 @@
+import type { Adapter, ReadyDeployResult } from '../../deployment/adapter/index.js';
+import type { InstallationEvidence } from './installation/index.js';
+export declare const DEPLOYMENT_EVIDENCE_VERSION: 1;
+/** Persist one non-secret, non-authoritative continuity observation atomically. */
+export declare function writeDeploymentEvidence(input: {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly adapter: Adapter<object>;
+    readonly deployment: ReadyDeployResult;
+    readonly installation?: InstallationEvidence;
+}): Promise<string>;

package/dist/tooling/cli/evidence.js

@@ -0,0 +1,53 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export const DEPLOYMENT_EVIDENCE_VERSION = 1;
+/** Persist one non-secret, non-authoritative continuity observation atomically. */
+export async function writeDeploymentEvidence(input) {
+    const directory = join(input.projectDir, '.astrale', 'environments', input.environment);
+    const path = join(directory, 'deployment.json');
+    await mkdir(directory, { recursive: true });
+    const provider = input.deployment.progress.provider.evidence;
+    const value = Object.freeze({
+        version: DEPLOYMENT_EVIDENCE_VERSION,
+        environment: input.environment,
+        adapter: Object.freeze({ name: input.adapter.name, version: input.adapter.version }),
+        deployment: Object.freeze({
+            provider: provider.provider,
+            id: provider.deployment,
+            artifact: provider.artifact,
+            issuer: input.deployment.release.addressing.issuer,
+            publicUrl: input.deployment.release.addressing.publicUrl,
+            origin: input.deployment.release.publication.origin,
+            revision: input.deployment.release.publication.schema.revision,
+            etag: input.deployment.release.publication.etag,
+            readiness: 'ready',
+            ...(provider.preflight === undefined ? {} : { preflight: provider.preflight }),
+        }),
+        ...(input.installation === undefined
+            ? {}
+            : {
+                installation: Object.freeze({
+                    instance: input.installation.instance,
+                    origin: input.installation.origin,
+                    issuer: input.installation.issuer,
+                    revision: input.installation.revision,
+                    etag: input.installation.etag,
+                    generation: input.installation.generation,
+                    status: input.installation.status,
+                }),
+            }),
+    });
+    const staging = join(directory, `.deployment-${randomUUID()}.json`);
+    await writeFile(staging, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+    try {
+        await rename(staging, path);
+    }
+    finally {
+        await unlink(staging).catch((cause) => {
+            if (cause.code !== 'ENOENT')
+                throw cause;
+        });
+    }
+    return path;
+}

package/dist/tooling/cli/help.js

@@ -12,17 +12,19 @@ export function helpText(command) {
 export const ERROR_USAGE = `Usage: astrale-domain <command> [options]
 Run "astrale-domain --help" for available commands.
 `;
-const GLOBAL_HELP = `Build, develop, deploy, lint, and package Astrale Domains.
+const GLOBAL_HELP = `Build, develop, deploy, test, lint, and package Astrale Domains.
 
 Usage:
   astrale-domain <command> [options]
 
 Commands:
-  dev [environment]       Build and run a watched development session.
+  dev [environment]       Remotely deploy and watch one Project Environment.
   build                   Build and verify without deploying.
-  deploy <environment>    Deploy through the configured adapter.
+  deploy <environment>    Deploy and optionally install one Environment.
+  test                    Run Project tests, optionally against one Environment.
   lint                    Check Domain source and architecture.
   package                 Prepare public declarations for publication.
+  upgrade                 Update Astrale dependencies through pnpm (default: beta).
 
 Options:
   -h, --help              Show help.
@@ -30,51 +32,73 @@ Options:
 Run "astrale-domain <command> --help" for command-specific help.
 `;
 const COMMAND_HELP = Object.freeze({
-    dev: `Build, verify, and run a watched Domain development session.
+    upgrade: `Update existing Astrale dependencies in a pnpm project or workspace.
+
+Usage:
+  astrale-domain upgrade [--channel <tag>] [--check]
+
+Options:
+  --channel <tag>         Registry dist-tag to select (default: beta).
+  --check                 Show changes without modifying project files or installing.
+  -h, --help              Show help for upgrade.
+
+Behavior:
+  Updates dependencies, devDependencies, and optionalDependencies under @astrale-os/
+  and @astrale-domains/, including the workspace root. Writes exact versions and
+  runs pnpm install once. The selected tag is authoritative, even if older than
+  the current version. Installation is synchronized even when versions are unchanged,
+  so retrying can finish a previously failed install. Packages without that tag remain
+  unchanged with a warning.
+  Local links, catalogs, aliases, peers, and overrides are not rewritten.
+  Does not load astrale.config.ts, require Bun, run project checks, commit, or deploy.
+  Stop development watchers before upgrading. Review changes and run your project's
+  checks afterwards. Failed installations leave local changes available for repair.
+  For an older SDK without this command: pnpm dlx @astrale-os/sdk@beta upgrade.
+`,
+    dev: `Build, verify, remotely deploy, and watch one Project Environment.
 
 Usage:
   astrale-domain dev [environment] [options]
 
 Arguments:
-  environment             Adapter environment key (default: dev).
+  environment             Project Environment name; defaults to development.
 
 Options:
   --environment <name>    Select the environment without a positional argument.
-  --port <port>           Use a strict local Worker port (default: OS-allocated).
-  --host <url>            Use an externally managed public origin; requires a strict port
-                          from --port or adapter configuration.
+  --deploy-only           Suppress this run's configured Kernel installation.
+  --as <identity>         Select the Astrale identity for Services and installation calls.
   --session-file <path>   Write one retained DevelopmentSessionFileV1 snapshot at an
                           absolute path in a caller-owned private directory.
   --credential-file <path>
-                          Use one private operator credential for adapter-owned Kernel
-                          calls without exposing it in project configuration.
+                          Use one private operator credential for provider and Kernel
+                          calls without exposing it in Project configuration.
   --secrets-file <path>   Load one private, absolute secrets file for this development
                           session instead of the adapter-declared secrets file.
   -h, --help              Show help for dev.
 
 Behavior:
-  Builds and verifies the Application, Runtime, and adapter-prepared artifact.
-  Serves the generated Worker and an optional Vite frontend. Vite uses its own
-  OS-allocated loopback port.
-  Watches imported authored sources and declared secrets. Configuration changes
-  require restarting the command.
+  The selected Environment must exist; no other Environment is chosen as a fallback.
+  Builds and verifies the Application, Runtime, frontend, and adapter artifact, then
+  deploys it through the selected Environment. It never starts a local Worker,
+  Vite server, or tunnel. Imported source changes produce serialized remote updates;
+  configuration changes require restarting the command.
+  A shared direct-provider target additionally requires an external single-writer
+  boundary such as a CI/CD concurrency group.
   The session file is machine-readable and authoritative when requested; human
   stdout/stderr remains diagnostic. It requires an adapter that reports exact
-  installed Release evidence.
-  A credential file is read only by the installation-owning adapter. Its value is
-  never forwarded to the Domain runtime or written to the session file.
+  installed Release evidence, so it is rejected for an Environment without an
+  installation and when --deploy-only suppresses installation.
+  A credential file is admitted and read once. Its value is passed only to the
+  deployment adapter, configured Kernel installation, and default View; it never
+  enters Domain Runtime secrets, diagnostics, deployment evidence, or the session
+  file. It is currently unavailable on Windows because private no-reparse file
+  admission is absent.
   A secrets-file override is read once, passed to the Domain runtime as secrets,
   never mutates the authored project, and is not watched for later changes. It is
-  currently unavailable on Windows because private no-reparse admission is absent.
-
-Adapters:
-  cloudflare              Runs the local Worker and optional Vite frontend only;
-                          it owns no public ingress or Kernel installation.
-  astrale                 Also owns a Quick Tunnel when no public host is configured,
-                          reconciles each verified Release on the configured or
-                          CLI-active instance, and starts a local View host when
-                          a View is declared. The installation remains after the
-                          development session stops.
+  also unavailable on Windows because private no-reparse admission is absent.
+
+  Stopping the watcher stops only local build orchestration. The remote deployment
+  and optional Kernel installation remain available.
 `,
     build: `Build and verify a Domain without deploying it.
 
@@ -85,9 +109,9 @@ Options:
   -h, --help              Show help for build.
 
 Behavior:
-  Compiles the Application and Runtime, runs adapter preparation, and verifies
-  the resulting artifact. It does not load declared secrets, deploy, or install
-  the Domain.
+  Compiles the Application and verifies that the conventional or configured Runtime
+  module exports the exact Runtime owned by it. It does not select an Environment,
+  load secrets, deploy, or install the Domain.
 `,
     deploy: `Build, verify, and deploy a Domain through its configured adapter.
 
@@ -100,12 +124,32 @@ Arguments:
 
 Options:
   --environment <name>    Select the environment without a positional argument.
+  --deploy-only           Suppress this run's configured Kernel installation.
+  --as <identity>         Select the Astrale identity for Services and installation calls.
   -h, --help              Show help for deploy.
 
 Behavior:
-  Builds and verifies the Release, loads declared secrets, and invokes the
-  adapter deployment. Deployment does not install the deployed Domain on a
-  Kernel instance.
+  Builds and verifies the Application, Runtime, and provider artifact, loads declared
+  secrets, and invokes the selected adapter. It then verifies the resulting Release.
+  When the Environment declares installation, reconciles it after provider readiness.
+  An Environment without installation performs zero Kernel calls.
+`,
+    test: `Run Project tests locally or against one selected Environment.
+
+Usage:
+  astrale-domain test [options]
+
+Options:
+  --environment <name>    Select the committed Project Environment exposed to tests as
+                          ASTRALE_PROJECT_ENVIRONMENT.
+  --suite <name>          Select a named Vitest project from vitest.config.ts.
+  -h, --help              Show help for test.
+
+Behavior:
+  Without an Environment, runs the Project-local Vitest suite once. With an
+  Environment, first validates the name against astrale.config.ts, then exposes
+  that exact name to the selected suite. Test definitions remain Project-level;
+  environments never duplicate or override them.
 `,
     lint: `Check Domain source and architecture.
 

package/dist/tooling/cli/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * `@astrale-os/sdk/cli` — the `astrale-domain` CLI
- * (dev | build | deploy | lint | package), explicit dotenv boundary, and admitted
+ * (dev | build | deploy | test | lint | package), explicit dotenv boundary, and admitted
  * development-session file representation.
  *
  * Node-only: the CLI imports `node:fs`/`node:module`/`node:url` and runs under

package/dist/tooling/cli/index.js

@@ -1,6 +1,6 @@
 /**
  * `@astrale-os/sdk/cli` — the `astrale-domain` CLI
- * (dev | build | deploy | lint | package), explicit dotenv boundary, and admitted
+ * (dev | build | deploy | test | lint | package), explicit dotenv boundary, and admitted
  * development-session file representation.
  *
  * Node-only: the CLI imports `node:fs`/`node:module`/`node:url` and runs under

package/dist/tooling/cli/installation/index.d.ts

@@ -0,0 +1,2 @@
+export { reconcileInstallation } from './reconcile.js';
+export type { AstraleCommandResult, InstallationDependencies, InstallationEvidence, } from './reconcile.js';

package/dist/tooling/cli/installation/index.js

@@ -0,0 +1 @@
+export { reconcileInstallation } from './reconcile.js';

package/dist/tooling/cli/installation/observation.d.ts

@@ -0,0 +1,10 @@
+export interface InstallationObservation {
+    readonly origin: string;
+    readonly revision: string;
+    readonly issuer: string;
+    readonly generation: string;
+    readonly etag: string;
+}
+/** Admit exact installed Release evidence returned by Kernel introspection. */
+export declare function decodeInstallationObservation(input: string): InstallationObservation;
+export declare function canonicalIssuer(input: string): string;

package/dist/tooling/cli/installation/observation.js

@@ -0,0 +1,44 @@
+/** Admit exact installed Release evidence returned by Kernel introspection. */
+export function decodeInstallationObservation(input) {
+    let decoded;
+    try {
+        decoded = JSON.parse(input);
+    }
+    catch (cause) {
+        throw new TypeError('Astrale introspection did not return one JSON value.', { cause });
+    }
+    const root = record(decoded);
+    const publication = record(root.publication);
+    const identity = record(publication.identity);
+    if (typeof root.origin !== 'string' ||
+        typeof root.revision !== 'string' ||
+        typeof root.generation !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(root.generation) ||
+        publication.origin !== root.origin ||
+        publication.revision !== root.revision ||
+        typeof identity.issuer !== 'string' ||
+        typeof publication.etag !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(publication.etag)) {
+        throw new TypeError('Astrale introspection returned invalid installed Domain evidence.');
+    }
+    return Object.freeze({
+        origin: root.origin,
+        revision: root.revision,
+        issuer: canonicalIssuer(identity.issuer),
+        generation: root.generation,
+        etag: publication.etag,
+    });
+}
+export function canonicalIssuer(input) {
+    const url = new URL(input);
+    if (url.href !== url.origin && url.href !== `${url.origin}/`) {
+        throw new TypeError('Release issuer must be one canonical origin.');
+    }
+    return url.origin;
+}
+function record(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Astrale introspection returned invalid installed Domain evidence.');
+    }
+    return input;
+}