@astrale-os/sdk 0.6.0-beta.10 → 0.6.0-beta.12

package/dist/deployment/adapter/index.d.ts

@@ -1,4 +1,6 @@
-export type { Adapter, AdapterEnvironmentContext, AdapterInput, InstallationTarget, } from './adapter.js';
+export type { Adapter, AdapterEnvironmentContext, AdapterInput } from './adapter.js';
 export { defineAdapter, defineDeployment, isAdapter } from './define.js';
-export type * from './prepare/index.js';
-export type * from './deploy/index.js';
+export type * from './bundle/index.js';
+export type * from './release/index.js';
+/** @deprecated The contract before adapter interface v2; see `./legacy/index.ts`. */
+export type * from './legacy/index.js';

package/dist/deployment/adapter/legacy/adapter.d.ts

@@ -0,0 +1,50 @@
+import type { AdapterEnvironmentContext } from '../adapter.js';
+import type { Bundler } from '../bundle/index.js';
+import type { DeployContext, DeployResult } from './deploy/index.js';
+import type { ArtifactSource, PrepareContext } from './prepare/index.js';
+/**
+ * The instance an Environment's `installation` installs on after each deploy.
+ *
+ * @deprecated Deploy-time installation. Replacement: `astrale domain install <url> -i <instance>`
+ * after `astrale-domain deploy <environment>`, which never installs.
+ */
+export interface InstallationTarget {
+    readonly instance: string;
+    readonly identity?: string;
+}
+/**
+ * A provider adapter on the contract before adapter interface v2: `prepare` places a build at one
+ * stable target per Environment and `deploy` replaces that target's code in place. It declares no
+ * `deployRelease`, so every Environment it deploys is on the legacy direct-mode path (CT33). Like
+ * every adapter, it declares its `bundler`: `astrale-domain deploy` bundles first and `prepare`
+ * only places that Bundle.
+ *
+ * @deprecated Replacement: `Adapter` (adapter interface v2), whose `deployRelease` deploys one
+ * sealed release as one immutable deployment. See `./index.ts` for its consumers and removal.
+ */
+export interface LegacyAdapter<Parameters extends object = object> {
+    readonly kind: 'adapter';
+    readonly name: string;
+    readonly version: string;
+    /** Environment-free bytes `astrale-domain build` identifies by their build digest. */
+    readonly bundler: Bundler;
+    admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
+    prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
+    deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
+    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+}
+/**
+ * What `defineAdapter` admits for a `LegacyAdapter`.
+ *
+ * @deprecated Replacement: `AdapterInput` (adapter interface v2). See `./index.ts`.
+ */
+export interface LegacyAdapterInput<Parameters extends object> {
+    readonly name: string;
+    readonly version: string;
+    /** Environment-free bytes `astrale-domain build` identifies by their build digest. */
+    readonly bundler: Bundler;
+    admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
+    prepare(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
+    deploy(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
+    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+}

package/dist/deployment/adapter/{deploy → legacy/deploy}/context.d.ts

@@ -1,5 +1,11 @@
 import type { InstallationTarget } from '../adapter.js';
 import type { PreparedArtifact } from '../prepare/index.js';
+/**
+ * What a legacy `deploy` receives to replace one Environment's stable target in place.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement:
+ * `ReleaseDeployContext`, which `deployRelease` receives.
+ */
 export interface DeployContext {
     readonly projectDir: string;
     readonly environment: string;

package/dist/deployment/adapter/legacy/deploy/index.d.ts

@@ -0,0 +1,2 @@
+export type { DeployContext } from './context.js';
+export type { AppliedProviderDeployment, DeploymentPhase, DeploymentProgress, DeployResult, FailedDeployResult, ProviderDeploymentEvidence, ReadyDeployResult, } from './result.js';

package/dist/deployment/adapter/legacy/deploy/result.d.ts

@@ -0,0 +1,90 @@
+import type { Digest } from '@astrale-os/kernel-protocol/artifact';
+import type { BuildDigest } from '../../../build/index.js';
+import type { Addressing } from '../../../release/index.js';
+import type { Release } from '../../../release/legacy/index.js';
+import type { MutationKnowledge } from '../../release/index.js';
+/**
+ * Where a legacy `deploy` stopped.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement:
+ * `ReleaseDeploymentPhase`; an immutable deployment is neither addressed nor installed by its deploy.
+ */
+export type DeploymentPhase = 'prerequisite' | 'provider' | 'addressing' | 'release' | 'configuration' | 'installation' | 'readiness';
+/**
+ * What a provider reports for the stable target it replaced.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement: the
+ * `DeploymentRecordV1` of `ReadyReleaseDeployResult`; a provider deployment or version id never
+ * identifies an immutable deployment.
+ */
+export interface ProviderDeploymentEvidence {
+    readonly provider: string;
+    readonly deployment: string;
+    readonly artifact: Digest;
+    /**
+     * Build digest of the portable upload (modules and assets) this deployment was made from, which
+     * `astrale-domain deploy` compares with the Bundle it passed as `PrepareContext.bundle`. Present
+     * only when preparation placed that Bundle. A provider that bundles the upload again (Wrangler in
+     * direct mode) runs other bytes than these. Legacy prepare/deploy surface: deleted with it.
+     */
+    readonly build?: BuildDigest;
+    readonly issuer?: Addressing['issuer'];
+    /** Optional provider-side check before promotion; distinct from public readiness. */
+    readonly preflight?: 'passed' | 'unavailable';
+}
+/** @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). */
+export type AppliedProviderDeployment = {
+    readonly kind: 'applied';
+    readonly evidence: ProviderDeploymentEvidence & {
+        readonly issuer: Addressing['issuer'];
+    };
+};
+/**
+ * What a legacy `deploy` changed, effect by effect.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement:
+ * `FailedReleaseDeployResult.provider`; an immutable deployment's deploy installs nothing.
+ */
+export interface DeploymentProgress {
+    readonly prerequisite: MutationKnowledge;
+    readonly provider: MutationKnowledge<ProviderDeploymentEvidence>;
+    readonly configuration: MutationKnowledge;
+    readonly installation: MutationKnowledge;
+}
+/**
+ * A stable target replaced in place and ready.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement:
+ * `ReadyReleaseDeployResult`, the immutable deployment `deployRelease` created or reused.
+ */
+export interface ReadyDeployResult {
+    readonly status: 'ready';
+    readonly phase: 'complete';
+    readonly progress: DeploymentProgress & {
+        readonly provider: AppliedProviderDeployment;
+    };
+    /**
+     * The stable-target Release (v3 Publication) of the legacy `deploy` operation. A canonical deploy
+     * reaches its adapter through `deployRelease` with the v4 Release (CT23); D10 deletes `deploy`
+     * and this result with the direct-mode path.
+     */
+    readonly release: Release;
+}
+/**
+ * A legacy `deploy` that did not reach a ready stable target.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement:
+ * `FailedReleaseDeployResult`.
+ */
+export interface FailedDeployResult {
+    readonly status: 'failed';
+    readonly phase: DeploymentPhase;
+    readonly progress: DeploymentProgress;
+    readonly error: Error;
+    readonly release?: Release;
+}
+/**
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement:
+ * `ReleaseDeployResult`.
+ */
+export type DeployResult = ReadyDeployResult | FailedDeployResult;

package/dist/deployment/adapter/legacy/deploy/result.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/legacy/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The adapter contract before adapter interface v2: `prepare` places a build at one stable target
+ * per Environment, `deploy` replaces that target's code in place and may install it, and the
+ * stable target serves a v3 Publication under an issuer bound to it for life.
+ *
+ * @deprecated Replacement: `Adapter` (adapter interface v2): beside the same `bundler`, `configure`,
+ * `placement` and `deployRelease`, which deploys one sealed release as one immutable deployment,
+ * created or reused, and installs nothing.
+ *
+ * Short-term consumers: the legacy direct-mode path (CT33), which `astrale-domain deploy` and
+ * `astrale-domain dev` run through these operations:
+ * - adapter-cloudflare direct mode (`route`, `workerName`, `identityIssuer`, `addressing`,
+ *   `signingIdentity`, or no `namespace`), which serves the configurations of domains ai-gateway,
+ *   closing, grc, integrations and issues (until SV15), shell (until SH2), the Services
+ *   `development` environment (until SV9) and ui:domain (until UI1);
+ * - adapter-astrale, until S8 gives it `deployRelease`.
+ *
+ * Removal: D10, once no supported configuration selects the direct-mode path (CT33); it deletes
+ * these types with `prepare`/`deploy`, `src/deployment/release/legacy` and the stable-target CLI
+ * path.
+ */
+export type { InstallationTarget, LegacyAdapter, LegacyAdapterInput } from './adapter.js';
+export type * from './prepare/index.js';
+export type * from './deploy/index.js';

package/dist/deployment/adapter/legacy/index.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/legacy/prepare/artifact.d.ts

@@ -0,0 +1,43 @@
+import type { Digest } from '@astrale-os/kernel-protocol/artifact';
+import type { Build } from '../../../build/index.js';
+import type { Addressing } from '../../../release/index.js';
+import type { ArtifactFile, PreparedArtifactFile } from '../../bundle/index.js';
+/**
+ * Where the stable target of one Environment answers: configured by the author or assigned by the
+ * provider.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement: `Placement`,
+ * from which `deploymentUrl(label, placement.routingDomain)` derives an immutable deployment's URL.
+ */
+export type AddressingPlan = {
+    readonly kind: 'configured';
+    readonly addressing: Addressing;
+} | {
+    readonly kind: 'provider-assigned';
+    readonly claim: string;
+};
+/**
+ * Untrusted provider-specific preparation output admitted by verify/preflight.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement: the `Bundle`
+ * the adapter's `bundler` produces, which `deployRelease` receives.
+ */
+export interface ArtifactSource {
+    readonly entrypoint: string;
+    readonly files: readonly ArtifactFile[];
+    readonly addressing: AddressingPlan;
+}
+/**
+ * Exact detached input supplied to every provider deployment effect.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement: the `Bundle`
+ * and `FrozenConfigurationV1` that `deployRelease` receives.
+ */
+export interface PreparedArtifact<BuildValue extends Build = Build> {
+    readonly kind: 'prepared-artifact';
+    readonly build: BuildValue;
+    readonly digest: Digest;
+    readonly entrypoint: string;
+    readonly files: readonly PreparedArtifactFile[];
+    readonly addressing: AddressingPlan;
+}

package/dist/deployment/adapter/legacy/prepare/artifact.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/legacy/prepare/context.d.ts

@@ -0,0 +1,36 @@
+import type { Build } from '../../../build/index.js';
+import type { ResolvedRuntimeReference } from '../../../runtime/index.js';
+import type { Bundle } from '../../bundle/index.js';
+import type { InstallationTarget } from '../adapter.js';
+/**
+ * What `prepare` receives to produce the artifact of one Environment's stable target.
+ *
+ * @deprecated Legacy `prepare`/`deploy` contract (see `../index.ts`). Replacement: `configure`,
+ * `placement` and the Bundle of the adapter's `bundler`, which `deployRelease` receives.
+ */
+export interface PrepareContext<BuildValue extends Build = Build> {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly installation?: InstallationTarget;
+    /**
+     * Preparation purpose. Remote development and one-shot deployment both
+     * prepare complete release artifacts. Omitted by older custom callers means
+     * release for compatibility during the beta migration.
+     */
+    readonly mode?: 'release';
+    /**
+     * Optional preparation-input observer used by tooling that must rebuild when
+     * an adapter reads authored paths outside the Domain/Runtime module graph.
+     */
+    readonly recordSource?: (path: string) => void;
+    /** Parent-owned lifecycle cancellation shared by every preparation process/effect. */
+    readonly signal: AbortSignal;
+    readonly build: BuildValue;
+    readonly runtime: ResolvedRuntimeReference;
+    /**
+     * The environment-free Bundle of the adapter's own `bundler`, which `astrale-domain deploy`
+     * always produces first so that preparation only places it. Absent (an `astrale-domain dev`
+     * rebuild), the adapter bundles by itself. Legacy prepare/deploy surface: deleted with it.
+     */
+    readonly bundle?: Bundle<BuildValue>;
+}

package/dist/deployment/adapter/legacy/prepare/context.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/legacy/prepare/index.d.ts

@@ -0,0 +1,2 @@
+export type { PrepareContext } from './context.js';
+export type { AddressingPlan, ArtifactSource, PreparedArtifact } from './artifact.js';

package/dist/deployment/adapter/legacy/prepare/index.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/release/context.d.ts

@@ -0,0 +1,75 @@
+import type { DeploymentCommitV1, FrozenConfigurationV1, LineAddressing } from '../../address/index.js';
+import type { Release } from '../../release/index.js';
+import type { Bundle } from '../bundle/index.js';
+/** What `configure` receives: the Environment whose configuration it freezes, nothing else. */
+export interface ConfigureContext {
+    readonly environment: string;
+}
+/**
+ * Where the host places the deployments of one Environment. `routingDomain` is the DNS name every
+ * deployment URL ends with, `https://<label>.<routingDomain>`; `addressing` is how its line reads:
+ * `readable` for platform lines, `opaque` (the fingerprint alone) for tenant lines.
+ */
+export interface Placement {
+    readonly addressing: LineAddressing;
+    readonly routingDomain: string;
+}
+/** What `placement` receives. It answers without any effect at the host. */
+export interface PlacementContext {
+    readonly environment: string;
+    /** Parent-owned lifecycle cancellation. */
+    readonly signal: AbortSignal;
+    /** Optional command-scoped identity override (`--as`). */
+    readonly identity?: string;
+}
+/**
+ * Everything `deployRelease` deploys: one sealed release as one immutable deployment at
+ * `release.url`, which is `deploymentUrl(label, placement.routingDomain)` and the release's issuer.
+ * The SDK computes each value before the call, from the Build, `configure` and `placement`, so the
+ * adapter never derives an address or seals anything itself.
+ */
+export interface ReleaseDeployContext {
+    readonly projectDir: string;
+    readonly environment: string;
+    /** Optional command-scoped identity override (`--as`). */
+    readonly identity?: string;
+    /** Optional command-scoped credential; trusted adapters must neither retain nor disclose it. */
+    readonly credential?: string;
+    /**
+     * The Environment's current secrets. A new deployment binds them; a reused deployment has its
+     * own declared secrets rewritten in place. A deploy never writes another deployment's secrets.
+     */
+    readonly secrets: Readonly<Record<string, string>>;
+    /** The environment-free bytes of the adapter's `bundler`, identified by `bundle.digest`. */
+    readonly bundle: Bundle;
+    /** What `configure` froze for this Environment. */
+    readonly configuration: FrozenConfigurationV1;
+    /** Where `placement` said the host places the deployment. */
+    readonly placement: Placement;
+    /**
+     * `<line>-<content>`: the DNS label of the deployment, which is also its provider script. Its
+     * content covers `bundle.digest` and `configuration`, so one label serves one release.
+     */
+    readonly label: string;
+    /**
+     * The release the SDK sealed for this deployment before the call: its `document` is the
+     * `DomainRelease` v4 the deployment serves at `release.json`, its `url` the deployment URL.
+     */
+    readonly release: Release;
+    /** The commit the deployment is built from, as its deployment record declares it. */
+    readonly commit: DeploymentCommitV1 | null;
+    /** Parent-owned lifecycle cancellation shared by every provider effect. */
+    readonly signal: AbortSignal;
+}
+/** What `list` receives: the origin whose deployments the host lists for the caller. */
+export interface ListContext {
+    readonly origin: string;
+    readonly signal: AbortSignal;
+    readonly identity?: string;
+}
+/** What `retain` receives: the label of the published deployment to keep. */
+export interface RetainContext {
+    readonly label: string;
+    readonly signal: AbortSignal;
+    readonly identity?: string;
+}

package/dist/deployment/adapter/release/context.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/release/index.d.ts

@@ -0,0 +1,2 @@
+export type { ConfigureContext, ListContext, Placement, PlacementContext, ReleaseDeployContext, RetainContext, } from './context.js';
+export type { DeploymentSecretsState, FailedReleaseDeployResult, MutationKnowledge, ReadyReleaseDeployResult, ReleaseDeploymentPhase, ReleaseDeployResult, } from './result.js';

package/dist/deployment/adapter/release/index.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/adapter/release/result.d.ts

@@ -0,0 +1,56 @@
+import type { DeploymentRecordV1 } from '../../address/index.js';
+/** What one operation knows it changed at a provider. */
+export type MutationKnowledge<Evidence = unknown> = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'partial';
+    readonly evidence?: Evidence;
+} | {
+    readonly kind: 'applied';
+    readonly evidence: Evidence;
+} | {
+    readonly kind: 'unknown';
+};
+/**
+ * How a deploy left the Environment's secrets on the deployment it made or reused: `bound` to a
+ * new deployment, or `updated` or left `unchanged` in place on the reused one.
+ */
+export type DeploymentSecretsState = 'bound' | 'updated' | 'unchanged';
+/**
+ * The immutable deployment of one release, ready at its URL.
+ *
+ * - `created`: a new deployment now serves the release, and the Environment's secrets are `bound`
+ *   to it.
+ * - `reused`: the deployment of this exact release (same label, build and configuration) already
+ *   existed; its own declared secrets were `updated` or left `unchanged` in place.
+ */
+export interface ReadyReleaseDeployResult {
+    readonly status: 'ready';
+    readonly state: 'created' | 'reused';
+    /** The record the deployment declares, as the host stored it. */
+    readonly record: DeploymentRecordV1;
+    /** The deployment URL, which is also the issuer of the release it serves. */
+    readonly url: string;
+    readonly secrets: {
+        readonly state: DeploymentSecretsState;
+    };
+}
+/**
+ * Where a deploy of one release stopped:
+ * - `prerequisite`: before any effect at the host (a missing tool, credential or hosting answer);
+ * - `provider`: at the host, while it created or reused the deployment;
+ * - `readiness`: the deployment exists but did not serve its release before the deadline.
+ */
+export type ReleaseDeploymentPhase = 'prerequisite' | 'provider' | 'readiness';
+/**
+ * A deploy of one release that did not reach a ready deployment. Rerunning the same deploy
+ * converges: the deployment's label is its content, so a partial or applied deployment is reused.
+ */
+export interface FailedReleaseDeployResult {
+    readonly status: 'failed';
+    readonly phase: ReleaseDeploymentPhase;
+    /** What the host may now hold of the deployment. */
+    readonly provider: MutationKnowledge;
+    readonly error: Error;
+}
+export type ReleaseDeployResult = ReadyReleaseDeployResult | FailedReleaseDeployResult;

package/dist/deployment/adapter/release/result.js

@@ -0,0 +1 @@
+export {};

package/dist/deployment/address/configuration.d.ts

@@ -0,0 +1,83 @@
+import type { Digest } from '@astrale-os/kernel-protocol/artifact';
+export declare const FROZEN_CONFIGURATION_FORMAT = "astrale.deployment.configuration";
+export declare const FROZEN_CONFIGURATION_VERSION = 1;
+/**
+ * What a deploy freezes into one deployment beside its build: the author's plain variables and the
+ * execution settings, defaults resolved, the durable Workflow options it declares, and the services
+ * and dispatch namespaces it binds. It names the secrets a deployment binds, never their values,
+ * and leaves out what the host derives (the deployment URL, the build digest, the signing key). A
+ * changed variable, setting or binding is another configuration, so another address; a rotated
+ * secret is not.
+ *
+ * Its admission is canonical form only. Whether a Worker can run under it stays with the host that
+ * binds it: `encodeWorkerSettings` (`@astrale-os/adapter-cloudflare/worker`) refuses settings past
+ * the Worker bounds when the host writes `ASTRALE_SETTINGS`, before anything is uploaded, and the
+ * host's binding namespace admits the binding names.
+ */
+export interface FrozenConfigurationV1 {
+    readonly format: typeof FROZEN_CONFIGURATION_FORMAT;
+    readonly version: typeof FROZEN_CONFIGURATION_VERSION;
+    /** The author's plain variables, never secrets. */
+    readonly vars: Readonly<Record<string, string>>;
+    readonly settings: {
+        readonly maximumRequestBytes: number;
+        readonly invocationTimeoutMs: number;
+        readonly tokenExchange: false | {
+            readonly maximumLifetimeSeconds: number;
+        };
+        /** The durable Workflow options the Environment declares; absent when it declares none. */
+        readonly durableOptions?: FrozenDurableOptions;
+    };
+    readonly runtime: {
+        readonly compatibilityDate: string;
+        /** Sorted, unique. */
+        readonly compatibilityFlags: readonly string[];
+    };
+    readonly bindings: {
+        /** Sorted by name, unique; never the `ROUTER` binding, which `router` describes. */
+        readonly services: readonly {
+            readonly name: string;
+            readonly service: string;
+        }[];
+        /**
+         * Dispatch namespaces the deployment binds, sorted by binding name, unique; empty when it binds
+         * none. A binding name is a Worker binding name other than `ROUTER`, a namespace a Cloudflare
+         * dispatch namespace name. Which namespaces a deployment may bind is the host's to decide.
+         */
+        readonly dispatchNamespaces: readonly {
+            readonly name: string;
+            readonly namespace: string;
+        }[];
+        /** Names of the secrets the deployment binds, sorted, unique. */
+        readonly secrets: readonly string[];
+    };
+    readonly router: false | {
+        readonly service: string;
+        readonly hostSuffix: string;
+        readonly minLabels: number;
+    };
+}
+/**
+ * The durable Workflow options of one deployment, as declared: every field optional, each a
+ * positive integer. The SDK's durable serving bounds and defaults them when the Worker runs.
+ */
+export interface FrozenDurableOptions {
+    readonly retentionMs?: number;
+    readonly retry?: {
+        readonly initialIntervalMs?: number;
+        readonly maxAttempts?: number;
+        readonly maxIntervalMs?: number;
+    };
+    readonly stepTimeoutMs?: number;
+}
+/** A configuration before its canonical order: lists in any order, no format header. */
+export type FrozenConfigurationInput = Omit<FrozenConfigurationV1, 'format' | 'version'>;
+/** Freeze one deployment configuration in the one canonical order its digest is taken in. */
+export declare function frozenConfiguration(input: FrozenConfigurationInput): FrozenConfigurationV1;
+/**
+ * `sha256` of the canonical JSON (RFC 8785) of one exact, canonical frozen configuration. A
+ * deployment record keeps it whole; the deployment address keeps 80 bits of it with the build.
+ * It refuses a configuration that is not canonical, and checks nothing past that: a configuration
+ * it digests may still be one no Worker runs under (see `FrozenConfigurationV1`).
+ */
+export declare function configurationDigest(configuration: FrozenConfigurationV1): Digest;