@alneas/eaos-server 0.0.0-stage → 0.2.0

package/dist/lifecycle-engine/index.js

@@ -0,0 +1,41 @@
+import {
+  FRAMEWORK_VERSION,
+  PluginLifecycle,
+  assertBackendMigrationCutover,
+  assertBackendMigrationVerification,
+  assertDataContractBinding,
+  assertJsonDocumentContracts,
+  canonical,
+  collectSchemaMigrations,
+  createDataContractBaseline,
+  createJsonDocumentAssertion,
+  dataContractTables,
+  emptyLifecyclePlatformState,
+  emptyLifecycleState,
+  lifecycleDigest,
+  normalizeLifecycleState,
+  planBackendMigration,
+  rebaseDataContractBaseline,
+  resolveDataContracts
+} from "../chunk-SDJNYPYK.js";
+export {
+  FRAMEWORK_VERSION,
+  PluginLifecycle,
+  assertBackendMigrationCutover,
+  assertBackendMigrationVerification,
+  assertDataContractBinding,
+  assertJsonDocumentContracts,
+  canonical,
+  collectSchemaMigrations,
+  createDataContractBaseline,
+  createJsonDocumentAssertion,
+  dataContractTables,
+  emptyLifecyclePlatformState,
+  emptyLifecycleState,
+  lifecycleDigest,
+  normalizeLifecycleState,
+  planBackendMigration,
+  rebaseDataContractBaseline,
+  resolveDataContracts
+};
+//# sourceMappingURL=index.js.map

package/dist/lifecycle-engine/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lifecycle-engine/platform/artifacts.d.ts

@@ -0,0 +1,4 @@
+import '@alneas/eaos-core/plugin-sdk';
+import '../index.js';
+export { d as DeploymentInventory, j as PlatformContribution, P as PlatformPackage, m as validatePlatformPackages } from '../../artifacts-CteHmCMI.js';
+import '@alneas/eaos-core/contracts/data-contracts';

package/dist/lifecycle-engine/platform/artifacts.js

@@ -0,0 +1,7 @@
+import {
+  validatePlatformPackages
+} from "../../chunk-HCKAGLLB.js";
+export {
+  validatePlatformPackages
+};
+//# sourceMappingURL=artifacts.js.map

package/dist/lifecycle-engine/platform/artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lifecycle-engine/platform/control-plane.d.ts

@@ -0,0 +1,12 @@
+import '../index.js';
+export { PlatformAdminAction, PlatformAdminAuditEvent, PlatformAdminAuthorization, PlatformAdminPrincipal, PlatformBackendRecord, PlatformControlStore, PlatformMigrationReconcileAction, PlatformPlacementExecutor, PlatformTenantCreateInput, PlatformTenantPatch, PlatformTenantRecord, TenantBackendPlacement } from './index.js';
+import '@alneas/eaos-core/contracts/data-contracts';
+import '@alneas/eaos-core/security/gatekeeper';
+import '../../artifacts-CteHmCMI.js';
+import '@alneas/eaos-core/plugin-sdk';
+import './deployment-placements.js';
+import './runtime.js';
+import './database-router.js';
+import '@alneas/eaos-core/db/adapter';
+import './user-directory.js';
+import './site-publication.js';

package/dist/lifecycle-engine/platform/control-plane.js

@@ -0,0 +1,2 @@
+import "../../chunk-55D4ERWO.js";
+//# sourceMappingURL=control-plane.js.map

package/dist/lifecycle-engine/platform/control-plane.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lifecycle-engine/platform/database-router.d.ts

@@ -0,0 +1,118 @@
+import { DatabaseAdapter, TenantSessionContext, ConnectionStats } from '@alneas/eaos-core/db/adapter';
+import { BackendTarget } from '../index.js';
+import '@alneas/eaos-core/contracts/data-contracts';
+
+/**
+ * Routes verified tenant operations to isolated existing database pools without implicit fallback.
+ *
+ *
+ * One execution host, isolated pools per DB. No implicit shared fallback or unscoped business access.
+ * @remarks
+ * All configured adapters must share one dialect. The host supplies membership-verified tenant context, trusted target resolution and real adapter pools. Unscoped business connections always reject; administration requires a separate control adapter. close owns and closes every distinct supplied adapter.
+ *
+ * @example
+ * ```typescript
+ * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+ * import type { DatabaseAdapter } from '@alneas/eaos-core/db/adapter';
+ * import type { BackendTarget } from '@alneas/eaos-server/lifecycle-engine';
+ * export function connectRouter(resolve: (verifiedTenantId: string) => BackendTarget, adapters: ReadonlyMap<string, DatabaseAdapter>) { return new TenantDatabaseRouter(resolve, adapters); }
+ * ```
+ */
+declare class TenantDatabaseRouter implements DatabaseAdapter {
+    private readonly resolveTarget;
+    /**
+     * The single SQL dialect shared by every configured adapter.
+     */
+    readonly type: DatabaseAdapter['type'];
+    private readonly adapters;
+    /**
+     * Snapshots configured physical database adapters and requires a single shared dialect.
+     * @param resolveTarget - Resolve the verified tenant to its trusted lifecycle backend; synchronous errors propagate.
+     * @param adapters - Nonempty map keyed by physical databaseId; adapter objects are shared and later owned by close().
+     * @throws Error for no adapters or multiple adapter dialects.
+     *
+     * @example
+     * ```typescript
+     * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+     * import type { DatabaseAdapter } from '@alneas/eaos-core/db/adapter';
+     * import type { BackendTarget } from '@alneas/eaos-server/lifecycle-engine';
+     * export function connectRouter(resolve: (verifiedTenantId: string) => BackendTarget, adapters: ReadonlyMap<string, DatabaseAdapter>) { return new TenantDatabaseRouter(resolve, adapters); }
+     * ```
+     */
+    constructor(resolveTarget: (verifiedTenantId: string) => BackendTarget, adapters: ReadonlyMap<string, DatabaseAdapter>);
+    /**
+     * Rejects unscoped business database access to require a verified tenant context.
+     * @typeParam T - Callback result type required by DatabaseAdapter; this method always rejects.
+     * @param _domain - Unused business domain; no connection is opened.
+     * @param _callback - Unused callback; it is never invoked.
+     * @returns A rejected Promise; this method never resolves a callback result.
+     * @throws Always rejects with the verified-context requirement.
+     *
+     * @example
+     * ```typescript
+     * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+     * export async function rejectUnscoped(router: TenantDatabaseRouter) { await router.withConnection('reports', async () => undefined); }
+     * ```
+     */
+    withConnection<T>(_domain: string, _callback: (connection: unknown) => Promise<T>): Promise<T>;
+    /**
+     * Delegates one verified tenant connection to its exact configured physical database adapter.
+     * @typeParam T - Value resolved by work on the selected tenant connection.
+     * @param domain - Business domain forwarded to the selected adapter.
+     * @param callback - Async work invoked by the adapter with its connection; must enforce resource permission.
+     * @param context - Verified nonblank trimmed tenant session; a copied context is forwarded.
+     * @returns The selected adapter callback result.
+     * @throws Rejects invalid tenant, dedicated mismatch, missing adapter or adapter/callback failure; target resolver errors may throw synchronously.
+     *
+     * @remarks
+     * Dedicated target tenant must match. Missing target adapters and dedicated failures never fall back to shared storage. Cancellation/transaction/connection cleanup follow the selected adapter contract.
+     *
+     * @example
+     * ```typescript
+     * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+     * export function withVerifiedTenant<T>(router: TenantDatabaseRouter, tenantId: string, work: (connection: unknown) => Promise<T>) { return router.withTenantConnection('reports', work, { tenantId }); }
+     * ```
+     */
+    withTenantConnection<T>(domain: string, callback: (connection: unknown) => Promise<T>, context: TenantSessionContext): Promise<T>;
+    /**
+     * Checks every distinct configured database adapter concurrently.
+     * @returns True only when every adapter ping resolves true; false if any resolves false.
+     * @throws Rejects if any adapter ping rejects.
+     *
+     * @example
+     * ```typescript
+     * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+     * export const health = (router: TenantDatabaseRouter) => router.ping();
+     * ```
+     */
+    ping(): Promise<boolean>;
+    /**
+     * Aggregates connection and pool counts from every distinct configured adapter.
+     * @returns ConnectionStats with the router dialect and summed counts.
+     * @throws Propagates adapter getStats errors.
+     *
+     * @example
+     * ```typescript
+     * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+     * export const stats = (router: TenantDatabaseRouter) => router.getStats();
+     * ```
+     */
+    getStats(): ConnectionStats;
+    /**
+     * Closes all distinct configured adapters and collects asynchronous cleanup failures.
+     * @returns Resolves without a value after every adapter close settles successfully.
+     * @throws Rejects with AggregateError for one or more rejected close Promises; synchronous adapter errors may also reject.
+     *
+     * @remarks
+     * The router does not mark itself closed or make repeated calls idempotent; each adapter owns its lifecycle semantics. A synchronously throwing close implementation can interrupt initial dispatch.
+     *
+     * @example
+     * ```typescript
+     * import { TenantDatabaseRouter } from '@alneas/eaos-server/platform/database-router';
+     * export async function shutdown(router: TenantDatabaseRouter) { await router.close(); }
+     * ```
+     */
+    close(): Promise<void>;
+}
+
+export { TenantDatabaseRouter };

package/dist/lifecycle-engine/platform/database-router.js

@@ -0,0 +1,7 @@
+import {
+  TenantDatabaseRouter
+} from "../../chunk-LOUGW6MU.js";
+export {
+  TenantDatabaseRouter
+};
+//# sourceMappingURL=database-router.js.map

package/dist/lifecycle-engine/platform/database-router.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lifecycle-engine/platform/deployment-placements.d.ts

@@ -0,0 +1,464 @@
+import { DeploymentInventory } from './artifacts.js';
+import { DeploymentComponent, DeploymentTaskStatus, DeploymentTarget, DeploymentResult, DeploymentReceipt, deploymentComponentKinds, deploymentActions } from './deployment.js';
+import '@alneas/eaos-core/plugin-sdk';
+import '../index.js';
+import '@alneas/eaos-core/contracts/data-contracts';
+
+/**
+ * Explicit existing host service/resource or physical database destination with a binding revision.
+ *
+ * @see summarizePlacedDeployment for canonical integration usage.
+ */
+interface DeploymentDestination {
+    /**
+     * Unique destination identifier.
+     */
+    id: string;
+    /**
+     * Host/container/function/database/cloud/native/external destination category.
+     */
+    placement: DeploymentComponent['placement'];
+    /**
+     * Optional symbolic existing frontend/backend/worker role; host/container only.
+     *
+     * Symbolic role of an existing Platform service.
+     */
+    service?: 'frontend' | 'backend' | 'worker';
+    /**
+     * Optional nonsecret host resource/operation binding; never credentials or executable code.
+     *
+     * Host-owned resource/operation binding reference, never credentials or an executable command.
+     */
+    reference?: string;
+    /**
+     * Required existing backend ID for database destinations; forbidden otherwise.
+     */
+    backendId?: string;
+    /**
+     * Required exact physical database identity for database destinations.
+     */
+    databaseId?: string;
+    /**
+     * Optional dedicated concrete tenant restriction; database destinations only.
+     *
+     * Restrict a dedicated DB destination to its verified tenant.
+     */
+    tenantId?: string;
+    /**
+     * Nonblank host binding revision; change when wiring/provider/credential revision changes.
+     *
+     * Change when the host binding changes, including a credential/provider revision.
+     */
+    revision: string;
+}
+/**
+ * Explicit plugin selection and destination assignments; empty lists deliberately decline optional components.
+ *
+ * @see summarizePlacedDeployment for canonical integration usage.
+ */
+interface DeploymentPlacements {
+    /**
+     * Unique nonsecret existing destination declarations.
+     */
+    destinations: DeploymentDestination[];
+    /**
+     * Selected owner/plugin pairs and complete component-ID to destination-ID lists; selection never registers/enables code.
+     *
+     * Listing a plugin selects it for this application plan; this never registers or enables code.
+     */
+    plugins: Array<{
+        /**
+         * Exact inventory owner selecting this plugin.
+         */
+        owner: string;
+        /**
+         * Plugin declared by that owner; listing it selects application placement only.
+         */
+        pluginId: string;
+        /**
+         * Complete component-ID to destination-ID lists; empty declines only optional capabilities.
+         */
+        components: Record<string, string[]>;
+    }>;
+}
+/**
+ * Validates nonsecret destination definitions and explicit component-to-destination selections.
+ *
+ * Validate only non-secret declarations here; no service discovery, provisioning or code execution.
+ * @param value - Untrusted destinations/plugins declaration.
+ * @returns Completes without a value and narrows the input to DeploymentPlacements.
+ * @throws Error for duplicate/unknown IDs, unknown fields, invalid placement kind, malformed host references or conflicting destination configuration.
+ *
+ * @remarks
+ * A database destination uses exact backend/database IDs; other destinations use exactly one symbolic service or host reference. Dedicated tenant restrictions apply only to database destinations. No discovery, provisioning or code execution occurs.
+ *
+ * @example
+ * ```typescript
+ * import { validateDeploymentPlacements } from '@alneas/eaos-server/platform/deployment-placements';
+ * const placements: unknown = { destinations: [], plugins: [] };
+ * validateDeploymentPlacements(placements);
+ * ```
+ */
+declare function validateDeploymentPlacements(value: unknown): asserts value is DeploymentPlacements;
+/**
+ * Resolves each selected plugin component against explicit compatible deployment destinations.
+ *
+ * All selected components are explicit; [] means an optional capability was deliberately not adopted.
+ * @param placements - Validated explicit selections; every component must have a destination list.
+ * @param inventories - Trusted inventories with unique owner IDs and declared plugin work.
+ * @returns Component selections with copied destinationIds and adopted flags; an empty list deliberately declines an optional component.
+ * @throws Error for unknown inventory/plugin/component/destination, duplicate owners, missing required placement, incompatible role/kind or declined dependency.
+ *
+ * @remarks
+ * Selecting a plugin does not register or enable it. Required components cannot be declined, and adopted work cannot depend on declined nonartifact work. A host component may target a container destination.
+ *
+ * @example
+ * ```typescript
+ * import { resolveDeploymentPlacements } from '@alneas/eaos-server/platform/deployment-placements';
+ * import type { DeploymentInventory } from '@alneas/eaos-server/platform/artifacts';
+ * export function resolve(placements: Parameters<typeof resolveDeploymentPlacements>[0], inventories: DeploymentInventory[]) { return resolveDeploymentPlacements(placements, inventories); }
+ * ```
+ */
+declare function resolveDeploymentPlacements(placements: DeploymentPlacements, inventories: DeploymentInventory[]): {
+    owner: string;
+    pluginId: string;
+    componentId: string;
+    destinationIds: string[];
+    adopted: boolean;
+}[];
+/**
+ * Hashes a selected plugin's normalized component destinations and host binding revisions.
+ * @param placements - Previously validated placement declaration.
+ * @param owner - Inventory owner selecting the plugin.
+ * @param pluginId - Selected plugin ID.
+ * @param bindings - Optional nonsecret destination-ID to host-binding revision map; defaults to none.
+ * @returns A lowercase SHA-256 hash bound to selected components, referenced destinations and applicable binding revisions.
+ * @throws Error when the owner/plugin selection is absent or canonical serialization fails.
+ *
+ * @remarks
+ * Order of component/destination maps is normalized. Change binding revisions when provider credentials or host wiring change so old scoped evidence becomes stale.
+ *
+ * @example
+ * ```typescript
+ * import { deploymentPlacementHash, type DeploymentPlacements } from '@alneas/eaos-server/platform/deployment-placements';
+ * export function bindingDigest(placements: DeploymentPlacements, owner: string, pluginId: string) { return deploymentPlacementHash(placements, owner, pluginId); }
+ * ```
+ */
+declare function deploymentPlacementHash(placements: DeploymentPlacements, owner: string, pluginId: string, bindings?: Record<string, string>): string;
+/**
+ * Builds a scoped task target from a reviewed destination and the current inspection context.
+ * @param destination - Validated destination with optional exact database and dedicated-tenant identities.
+ * @param scope - Environment work omits tenant; tenant work requires a matching concrete tenant.
+ * @param context - Current environment/tenant context; omitted cannot resolve a target.
+ * @returns A new target object, or undefined for missing context/tenant or dedicated-tenant mismatch.
+ *
+ * @remarks
+ * Backend/database come from the destination, not the context. This performs no authority or resource-existence checks.
+ *
+ * @example
+ * ```typescript
+ * import { deploymentExecutionTarget } from '@alneas/eaos-server/platform/deployment-placements';
+ * const target = deploymentExecutionTarget({ id: 'web', placement: 'host', service: 'frontend', revision: '1' }, 'environment', { environment: 'review' });
+ * ```
+ */
+declare function deploymentExecutionTarget(destination: DeploymentDestination, scope: 'environment' | 'tenant', context?: DeploymentTarget): DeploymentTarget | undefined;
+/**
+ * One task instance at an explicit destination or reusable artifact scope.
+ *
+ * @see summarizePlacedDeployment for canonical integration usage.
+ */
+interface DeploymentExecution {
+    /**
+     * Declared plugin task ID.
+     */
+    taskId: string;
+    /**
+     * Scoped destination identity; absent for shared artifact work.
+     */
+    destinationId?: string;
+    /**
+     * Adopted components covered at this destination.
+     */
+    componentIds: string[];
+    /**
+     * Whether this adopted execution must succeed for completion.
+     */
+    required: boolean;
+    /**
+     * Dependency-aware derived task state.
+     */
+    status: DeploymentTaskStatus;
+    /**
+     * Resolved environment/database/tenant evidence context, if available.
+     */
+    target?: DeploymentTarget;
+    /**
+     * Latest matching reported result, if any.
+     */
+    result?: DeploymentResult;
+    /**
+     * Prerequisite task/destination identities whose evidence must succeed first.
+     */
+    dependencies: Array<{
+        /**
+         * Prerequisite declared task ID.
+         */
+        taskId: string;
+        /**
+         * Prerequisite destination, absent for shared artifact work.
+         */
+        destinationId?: string;
+    }>;
+}
+/**
+ * Builds one placement-bound execution graph shared by plugin and destination evidence projections.
+ *
+ * One execution graph powers both plugin and destination projections. Shared artifact work is never duplicated.
+ * @param inventory - Trusted artifact inventory with declared plugin work.
+ * @param inventorySha256 - Trusted lowercase inventory digest.
+ * @param receipts - Reported task evidence, including placement-bound scoped results.
+ * @param placements - Explicit compatible destination selections.
+ * @param context - Optional environment and tenant only; backend/database must come from destinations.
+ * @param bindings - Optional destination host-binding revisions; defaults to none.
+ * @returns A deployment summary with selected/adopted components, task executions, destinations, artifact executions and explicit placement coverage.
+ * @throws Error for invalid placements/context/receipts, undeclared tasks, mismatched task scope or conflicting equal-time evidence.
+ *
+ * @remarks
+ * Shared artifact work is not duplicated. Old binding hashes are ignored as stale; declined optional components do not satisfy adopted dependency work. No task executes, and reported completion does not grant runtime admission.
+ *
+ * @example
+ * ```typescript
+ * import { summarizePlacedDeployment, type DeploymentPlacements } from '@alneas/eaos-server/platform/deployment-placements';
+ * import type { DeploymentInventory, DeploymentReceipt } from '@alneas/eaos-server/platform';
+ * export function inspectPlaced(inventory: DeploymentInventory, digest: string, receipts: DeploymentReceipt[], placements: DeploymentPlacements) { return summarizePlacedDeployment(inventory, digest, receipts, placements, { environment: 'review' }); }
+ * ```
+ */
+declare function summarizePlacedDeployment(inventory: DeploymentInventory, inventorySha256: string, receipts: DeploymentReceipt[], placements: DeploymentPlacements, context?: DeploymentTarget, bindings?: Record<string, string>): {
+    plugins: ({
+        selected: boolean;
+        components: {
+            adopted: boolean;
+            destinationIds: string[];
+            complete: boolean;
+            id: string;
+            required?: boolean;
+            kind: typeof deploymentComponentKinds[number];
+            placement: "host" | "container" | "function" | "database" | "cloud" | "native" | "external";
+            runtime?: string;
+            assets?: string[];
+            assetPatterns?: string[];
+            entry?: string;
+            dataContracts?: Record<string, string>;
+            requirements?: {
+                tools?: Record<string, string>;
+                bindings?: string[];
+                adapters?: string[];
+            };
+        }[];
+        tasks: {
+            adopted: boolean;
+            executions: DeploymentExecution[];
+            status: DeploymentTaskStatus;
+            result?: DeploymentResult;
+            id: string;
+            componentIds: string[];
+            action: typeof deploymentActions[number];
+            scope: "artifact" | "environment" | "tenant";
+            required: boolean;
+            dependsOn: string[];
+            executor: string;
+            argv?: string[];
+            instructions?: string;
+        }[];
+        complete: boolean;
+        id: string;
+        artifactResolved: boolean;
+    } | {
+        selected: boolean;
+        placementSha256: string;
+        tasks: {
+            adopted: boolean;
+            required: boolean;
+            status: DeploymentTaskStatus;
+            executions: DeploymentExecution[];
+            result?: DeploymentResult;
+            id: string;
+            componentIds: string[];
+            action: typeof deploymentActions[number];
+            scope: "artifact" | "environment" | "tenant";
+            dependsOn: string[];
+            executor: string;
+            argv?: string[];
+            instructions?: string;
+        }[];
+        complete: boolean;
+        components: {
+            adopted: boolean;
+            destinationIds: string[];
+            complete: boolean;
+            id: string;
+            required?: boolean;
+            kind: typeof deploymentComponentKinds[number];
+            placement: "host" | "container" | "function" | "database" | "cloud" | "native" | "external";
+            runtime?: string;
+            assets?: string[];
+            assetPatterns?: string[];
+            entry?: string;
+            dataContracts?: Record<string, string>;
+            requirements?: {
+                tools?: Record<string, string>;
+                bindings?: string[];
+                adapters?: string[];
+            };
+        }[];
+        id: string;
+        artifactResolved: boolean;
+    })[];
+    complete: boolean;
+    ignoredReceipts: {
+        owner: string;
+        reason: string;
+    }[];
+    placementCoverage: "explicit";
+    destinations: {
+        executions: {
+            pluginId: string;
+            owner: string;
+            /**
+             * Declared plugin task ID.
+             */
+            taskId: string;
+            /**
+             * Scoped destination identity; absent for shared artifact work.
+             */
+            destinationId?: string;
+            /**
+             * Adopted components covered at this destination.
+             */
+            componentIds: string[];
+            /**
+             * Whether this adopted execution must succeed for completion.
+             */
+            required: boolean;
+            /**
+             * Dependency-aware derived task state.
+             */
+            status: DeploymentTaskStatus;
+            /**
+             * Resolved environment/database/tenant evidence context, if available.
+             */
+            target?: DeploymentTarget;
+            /**
+             * Latest matching reported result, if any.
+             */
+            result?: DeploymentResult;
+            /**
+             * Prerequisite task/destination identities whose evidence must succeed first.
+             */
+            dependencies: Array<{
+                /**
+                 * Prerequisite declared task ID.
+                 */
+                taskId: string;
+                /**
+                 * Prerequisite destination, absent for shared artifact work.
+                 */
+                destinationId?: string;
+            }>;
+        }[];
+        /**
+         * Unique destination identifier.
+         */
+        id: string;
+        /**
+         * Host/container/function/database/cloud/native/external destination category.
+         */
+        placement: DeploymentComponent["placement"];
+        /**
+         * Optional symbolic existing frontend/backend/worker role; host/container only.
+         *
+         * Symbolic role of an existing Platform service.
+         */
+        service?: "frontend" | "backend" | "worker";
+        /**
+         * Optional nonsecret host resource/operation binding; never credentials or executable code.
+         *
+         * Host-owned resource/operation binding reference, never credentials or an executable command.
+         */
+        reference?: string;
+        /**
+         * Required existing backend ID for database destinations; forbidden otherwise.
+         */
+        backendId?: string;
+        /**
+         * Required exact physical database identity for database destinations.
+         */
+        databaseId?: string;
+        /**
+         * Optional dedicated concrete tenant restriction; database destinations only.
+         *
+         * Restrict a dedicated DB destination to its verified tenant.
+         */
+        tenantId?: string;
+        /**
+         * Nonblank host binding revision; change when wiring/provider/credential revision changes.
+         *
+         * Change when the host binding changes, including a credential/provider revision.
+         */
+        revision: string;
+    }[];
+    artifactExecutions: {
+        pluginId: string;
+        owner: string;
+        /**
+         * Declared plugin task ID.
+         */
+        taskId: string;
+        /**
+         * Scoped destination identity; absent for shared artifact work.
+         */
+        destinationId?: string;
+        /**
+         * Adopted components covered at this destination.
+         */
+        componentIds: string[];
+        /**
+         * Whether this adopted execution must succeed for completion.
+         */
+        required: boolean;
+        /**
+         * Dependency-aware derived task state.
+         */
+        status: DeploymentTaskStatus;
+        /**
+         * Resolved environment/database/tenant evidence context, if available.
+         */
+        target?: DeploymentTarget;
+        /**
+         * Latest matching reported result, if any.
+         */
+        result?: DeploymentResult;
+        /**
+         * Prerequisite task/destination identities whose evidence must succeed first.
+         */
+        dependencies: Array<{
+            /**
+             * Prerequisite declared task ID.
+             */
+            taskId: string;
+            /**
+             * Prerequisite destination, absent for shared artifact work.
+             */
+            destinationId?: string;
+        }>;
+    }[];
+    owner: string;
+    inventorySha256: string;
+    target: DeploymentTarget | undefined;
+    coverage: "declared" | "legacy-unclassified";
+    artifactResolved: boolean;
+    evidencePolicy: string;
+};
+
+export { deploymentExecutionTarget, deploymentPlacementHash, resolveDeploymentPlacements, summarizePlacedDeployment, validateDeploymentPlacements };
+export type { DeploymentDestination, DeploymentExecution, DeploymentPlacements };