@alneas/eaos-server 0.0.0-stage → 0.2.0

package/dist/middleware/error-handler.d.ts

@@ -0,0 +1,35 @@
+import * as hono from 'hono';
+import { Context } from 'hono';
+
+/**
+ * Controls error response redaction and logging for {@link createErrorHandler}.
+ */
+interface ErrorHandlerOptions {
+    /** Hide message and stack when true; defaults to NODE_ENV === "production". */
+    isProduction?: boolean;
+    /** Called synchronously with the original error and request context before rendering; defaults to console.error. A thrown logger error propagates. */
+    logger?: (err: Error, c: Context) => void;
+}
+/**
+ * Creates a Hono error handler that logs errors and renders a JSON 500 response.
+ * @param options - Logging and redaction settings; omitted settings use console.error and NODE_ENV.
+ * @returns An async handler resolving to a 500 response; production responses omit stacks and use "Internal Server Error".
+ * @throws The returned handler rejects if the host logger throws.
+ * @remarks Nonproduction responses expose error messages and stacks. Choose production redaction explicitly for externally accessible services.
+ * @example
+ * ```typescript
+ * import { Hono } from "hono";
+ * import { createErrorHandler } from "@alneas/eaos-server/middleware/error-handler";
+ * const app = new Hono();
+ * app.onError(createErrorHandler({ isProduction: true }));
+ * app.get("/example", () => { throw new Error("example failure"); });
+ * console.log((await app.request("/example")).status); // 500
+ * ```
+ */
+declare function createErrorHandler(options?: ErrorHandlerOptions): (err: Error, c: Context) => Promise<Response & hono.TypedResponse<{
+    stack?: string | undefined;
+    error: string;
+}, 500, "json">>;
+
+export { createErrorHandler };
+export type { ErrorHandlerOptions };

package/dist/middleware/error-handler.js

@@ -0,0 +1,7 @@
+import {
+  createErrorHandler
+} from "../chunk-AVDMLTPF.js";
+export {
+  createErrorHandler
+};
+//# sourceMappingURL=error-handler.js.map

package/dist/middleware/error-handler.js.map

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

package/dist/middleware/module-guard.d.ts

@@ -0,0 +1,33 @@
+import * as hono from 'hono';
+import { EaosEnv } from '@alneas/eaos-core';
+
+/**
+ * Controls the explicit development bypass for {@link createModuleGuard}.
+ */
+interface ModuleGuardOptions {
+    /** Skip entitlement checks when true; defaults to NODE_ENV === "development". */
+    isDev?: boolean;
+}
+/**
+ * Rejects requests unless verified enabledModules contains the requested module or "all".
+ * @param moduleKey - Exact, case-sensitive entitlement key required by this route.
+ * @param options - Development bypass; see {@link ModuleGuardOptions}.
+ * @returns Hono middleware that responds with 403 for missing, malformed, or insufficient entitlements, or completes downstream handling without returning a value.
+ * @throws Request execution propagates downstream middleware rejections.
+ * @remarks Install authentication and trusted entitlement resolution first. This guard reads context only and does not query a contract store. The development bypass defaults from NODE_ENV.
+ * @example
+ * ```typescript
+ * import { Hono } from "hono";
+ * import type { EaosEnv } from "@alneas/eaos-core";
+ * import { createModuleGuard } from "@alneas/eaos-server/middleware/module-guard";
+ * const app = new Hono<EaosEnv>();
+ * app.use("/reports/*", createModuleGuard("reports", { isDev: false }));
+ * // Populate verified enabledModules in earlier host middleware to allow access.
+ * app.get("/reports/summary", c => c.json({ available: true }));
+ * console.log((await app.request("/reports/summary")).status); // 403
+ * ```
+ */
+declare function createModuleGuard(moduleKey: string, options?: ModuleGuardOptions): hono.MiddlewareHandler<EaosEnv, string, {}, Response>;
+
+export { createModuleGuard };
+export type { ModuleGuardOptions };

package/dist/middleware/module-guard.js

@@ -0,0 +1,7 @@
+import {
+  createModuleGuard
+} from "../chunk-VC2PCK2S.js";
+export {
+  createModuleGuard
+};
+//# sourceMappingURL=module-guard.js.map

package/dist/middleware/module-guard.js.map

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

package/dist/platform-admin/index.d.ts

@@ -0,0 +1,37 @@
+import { Hono } from 'hono';
+import { PlatformAdminAuthorization, PlatformControlStore, PlatformAdminAuditEvent, PlatformPlacementExecutor } from '@alneas/eaos-server/platform';
+export { PlatformPlacementExecutor } from '@alneas/eaos-server/platform';
+export { LifecyclePlatformControlStore } from './store.js';
+import '@alneas/eaos-server/lifecycle-engine';
+
+/**
+ * Trusted control-plane authorization, persistence, audit, and optional migration execution dependencies.
+ * @see createPlatformAdminRouter.
+ */
+interface PlatformAdminRouterOptions extends PlatformAdminAuthorization {
+    /** Shared authoritative tenant/backend/placement store. */
+    store: PlatformControlStore;
+    /** Awaited on denied and successful mutations; receives operator/action/outcome/time, without request credentials. Audit failure may occur after persistence. */
+    audit: (event: Readonly<PlatformAdminAuditEvent>) => Promise<void>;
+    /** Optional host migration executor; absent returns 501 for execute requests. Provisioning, credentials, and SQL remain host-owned. */
+    placementExecutor?: PlatformPlacementExecutor;
+    /** Clock for audit/plan timestamps; defaults to fresh Date. */
+    now?: () => Date;
+}
+/**
+ * Platform-wide control routes. They operate on host-registered opaque
+ * backends; provisioning, credentials, SQL and tenant membership remain host-owned.
+ * @param options - Shared store, live platform-admin authorization, audit sink, optional placement executor, and clock.
+ * @returns A Hono router for tenants, backend discovery, placement planning/execution/status/rollback/reconciliation. Unauthenticated/unauthorized requests return 401/403.
+ * @throws Synchronously for missing store/auth/audit dependencies. Request-time reads/auth/audit can fail through Hono error handling; mutation failures are generally 400 or migration conflict 409 data.
+ * @remarks Every operation requires principal.isPlatformAdmin === true plus host authorize approval. Plan/rollback endpoints persist reviewed plans rather than directly changing routing. Execution verifies reports before cutover and records reconciling state on uncertain failures; host executor effects are not rolled back automatically. Reads expose opaque public backend metadata without credentials/SQL. A failed audit can follow a completed mutation, so errors do not prove no change occurred. No listener, deployment, or scheduler is started.
+ * @example
+ * ```typescript
+ * import { createPlatformAdminRouter, type PlatformAdminRouterOptions } from "@alneas/eaos-server/platform-admin";
+ * export function controlRoutes(options: PlatformAdminRouterOptions) { return createPlatformAdminRouter(options); }
+ * ```
+ */
+declare function createPlatformAdminRouter(options: PlatformAdminRouterOptions): Hono;
+
+export { createPlatformAdminRouter };
+export type { PlatformAdminRouterOptions };

package/dist/platform-admin/index.js

@@ -0,0 +1,11 @@
+import {
+  createPlatformAdminRouter
+} from "../chunk-753HWDSC.js";
+import {
+  LifecyclePlatformControlStore
+} from "../chunk-YMJ7BRKU.js";
+export {
+  LifecyclePlatformControlStore,
+  createPlatformAdminRouter
+};
+//# sourceMappingURL=index.js.map

package/dist/platform-admin/index.js.map

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

package/dist/platform-admin/store.d.ts

@@ -0,0 +1,346 @@
+import { LifecycleStore, BackendMigrationPlan, LifecyclePlatformMigrationRecord, BackendMigrationVerificationReport, BackendMigrationCutover } from '@alneas/eaos-server/lifecycle-engine';
+import { PlatformControlStore, PlatformTenantRecord, PlatformTenantCreateInput, PlatformTenantPatch, PlatformBackendRecord, TenantBackendPlacement, PlatformMigrationReconcileAction } from '@alneas/eaos-server/platform';
+
+/**
+ * Platform control facade backed by the same LifecycleStore snapshot and lock.
+ * Use this with SqlLifecycleStore for distributed hosts; it intentionally does
+ * not create a second platform database or a second placement authority.
+ * @remarks Mutations normalize one locked lifecycle snapshot, increment its revision, and persist it; transaction/CAS/lock recovery depend on the host LifecycleStore. This facade performs no caller authentication, SQL/infra provisioning, remote migration, or automatic retry. Authorize operators before invoking it and reconcile uncertain store failures.
+ * @example
+ * ```typescript
+ * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+ * import type { LifecycleStore } from "@alneas/eaos-server/lifecycle-engine";
+ * export function controlStore(lifecycle: LifecycleStore) { return new LifecyclePlatformControlStore(lifecycle); }
+ * ```
+ */
+declare class LifecyclePlatformControlStore implements PlatformControlStore {
+    private readonly lifecycle;
+    private readonly now;
+    /**
+     * Captures the shared authoritative lifecycle ledger and clock.
+     * @param lifecycle - Host store providing consistent reads and exclusive writer callbacks.
+     * @param now - Clock for mutation timestamps; defaults to a fresh Date.
+     */
+    constructor(lifecycle: LifecycleStore, now?: () => Date);
+    private read;
+    private mutate;
+    /**
+     * Lists tenant records from the authoritative normalized lifecycle snapshot.
+     * @returns Tenant records with cloned domains arrays, or an empty array.
+     * @throws Host read/normalization failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function listTenants(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["listTenants"]>) {
+     *   return store.listTenants(...args);
+     * }
+     * ```
+     */
+    listTenants(): Promise<readonly PlatformTenantRecord[]>;
+    /**
+     * Creates an active tenant and its initial backend routing record under the lifecycle writer lock.
+     * @param input - Valid scope ID, nonblank name, nonempty domain strings, and registered initial backendId; a dedicated backend must bind the same tenant.
+     * @returns Created tenant record with clock timestamps; initial routing revision is one.
+     * @throws Invalid input, duplicate tenant, missing/mismatched backend, or host lock/write/clock failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function createTenant(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["createTenant"]>) {
+     *   return store.createTenant(...args);
+     * }
+     * ```
+     */
+    createTenant(input: PlatformTenantCreateInput): Promise<PlatformTenantRecord>;
+    /**
+     * Updates an existing tenant name, active flag, or domains and refreshes updatedAt.
+     * @param tenantId - Existing valid tenant scope ID.
+     * @param patch - Optional nonblank name, boolean active, and nonempty nonblank domains; omitted fields remain unchanged.
+     * @returns Updated tenant with cloned domains.
+     * @throws Missing tenant, invalid supplied fields, or host lock/write/clock failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function updateTenant(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["updateTenant"]>) {
+     *   return store.updateTenant(...args);
+     * }
+     * ```
+     */
+    updateTenant(tenantId: string, patch: PlatformTenantPatch): Promise<PlatformTenantRecord>;
+    /**
+     * Registers an immutable backend placement identity and replaceable public metadata.
+     * @param backend - Valid backend/database IDs, dialect/mode, optional dedicated tenant binding, and metadata.
+     * @returns Materialized registered target with metadata.
+     * @throws Invalid target, changed placement for an existing ID, database dialect conflict, or host store failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function registerBackend(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["registerBackend"]>) {
+     *   return store.registerBackend(...args);
+     * }
+     * ```
+     */
+    registerBackend(backend: PlatformBackendRecord): Promise<PlatformBackendRecord>;
+    /**
+     * Materializes registered backend targets with their public metadata.
+     * @returns Backend list, or an empty array.
+     * @throws Host read/normalization failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function listBackends(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["listBackends"]>) {
+     *   return store.listBackends(...args);
+     * }
+     * ```
+     */
+    listBackends(): Promise<readonly PlatformBackendRecord[]>;
+    /**
+     * Reads a registered backend target and its public metadata.
+     * @param backendId - Valid registered backend scope ID.
+     * @returns Materialized backend, or null when unregistered.
+     * @throws Invalid ID or host read failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function getBackend(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["getBackend"]>) {
+     *   return store.getBackend(...args);
+     * }
+     * ```
+     */
+    getBackend(backendId: string): Promise<PlatformBackendRecord | null>;
+    /**
+     * Resolves a tenant routing record into its registered backend target.
+     * @param tenantId - Valid tenant scope ID.
+     * @returns Placement with routing revision/time and backend, or null when absent.
+     * @throws Invalid ID, dangling backend reference, or host read failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function getTenantPlacement(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["getTenantPlacement"]>) {
+     *   return store.getTenantPlacement(...args);
+     * }
+     * ```
+     */
+    getTenantPlacement(tenantId: string): Promise<TenantBackendPlacement | null>;
+    /**
+     * Persists an immutable migration plan after checking registered backend identities.
+     * @param plan - Reviewed plan matching currently registered source/target; identical saved plans may be accepted before completion.
+     * @returns No value; resolves after storing the plan and initial planned record if absent.
+     * @throws Unregistered/changed backend, conflicting reused plan ID, already completed plan, clone or host store failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function saveMigrationPlan(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["saveMigrationPlan"]>) {
+     *   return store.saveMigrationPlan(...args);
+     * }
+     * ```
+     */
+    saveMigrationPlan(plan: BackendMigrationPlan): Promise<void>;
+    /**
+     * Reads a cloned persisted migration plan by ID.
+     * @param migrationId - Valid migration scope ID.
+     * @returns Plan clone, or null when absent.
+     * @throws Invalid ID or host read/clone failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function getMigrationPlan(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["getMigrationPlan"]>) {
+     *   return store.getMigrationPlan(...args);
+     * }
+     * ```
+     */
+    getMigrationPlan(migrationId: string): Promise<BackendMigrationPlan | null>;
+    /**
+     * Reads the persisted migration execution/reconciliation record.
+     * @param migrationId - Valid migration scope ID.
+     * @returns Cloned status record, or null when absent.
+     * @throws Invalid ID or host read/clone failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function getMigrationStatus(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["getMigrationStatus"]>) {
+     *   return store.getMigrationStatus(...args);
+     * }
+     * ```
+     */
+    getMigrationStatus(migrationId: string): Promise<LifecyclePlatformMigrationRecord | null>;
+    /**
+     * Binds an execution token and transitions a tenant migration record to running.
+     * @param input - Verified tenantId, persisted migrationId, and unique host executionId; plan scope must include the tenant.
+     * @returns Cloned running record, or completed cutover/rolled-back record unchanged.
+     * @throws Missing plan, tenant mismatch, conflicting active token, reconciling state, invalid IDs, or host store failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function beginMigrationExecution(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["beginMigrationExecution"]>) {
+     *   return store.beginMigrationExecution(...args);
+     * }
+     * ```
+     */
+    beginMigrationExecution(input: {
+        /**
+         * Verified tenant included in the persisted migration plan tenant scope; mismatch rejects before recording execution.
+         */
+        tenantId: string;
+        /**
+         * Identity of an already persisted migration plan and its corresponding status record.
+         */
+        migrationId: string;
+        /**
+         * Host execution token bound to this run; a different token cannot replace an active running/verified execution.
+         */
+        executionId: string;
+    }): Promise<LifecyclePlatformMigrationRecord>;
+    /**
+     * Records verified migration evidence and cutover data for the active execution token.
+     * @param input - Tenant, exact persisted plan, active executionId, verification report, and matching validated cutover.
+     * @returns Cloned verified migration record.
+     * @throws Invalid cutover/report, nonpersisted/changed plan, tenant/token/state mismatch, changed retry verification, or host store failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function recordMigrationVerification(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["recordMigrationVerification"]>) {
+     *   return store.recordMigrationVerification(...args);
+     * }
+     * ```
+     */
+    recordMigrationVerification(input: {
+        /**
+         * Verified tenant included in the exact persisted plan tenant scope.
+         */
+        tenantId: string;
+        /**
+         * Exact persisted migration plan; canonical contents must match the saved plan rather than a modified caller copy.
+         */
+        plan: BackendMigrationPlan;
+        /**
+         * Current execution token recorded by beginMigrationExecution; only running/verified records with this token may accept evidence.
+         */
+        executionId: string;
+        /**
+         * Passing source/target verification report validated against the plan and cutover; a verified retry must reproduce the recorded report.
+         */
+        verification: BackendMigrationVerificationReport;
+        /**
+         * Matching validated cutover proof recorded with the report for a later explicit routing commit; recording verification does not itself switch placement.
+         */
+        cutover: BackendMigrationCutover;
+    }): Promise<LifecyclePlatformMigrationRecord>;
+    /**
+     * Records a failed or reconciling migration status with host diagnostic text.
+     * @param input - Persisted migrationId, optional expected executionId, failure status, and nonblank message up to 2048 characters.
+     * @returns Cloned updated failure record.
+     * @throws Missing/completed migration, mismatched token, invalid input, or host store/clock failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function markMigrationFailure(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["markMigrationFailure"]>) {
+     *   return store.markMigrationFailure(...args);
+     * }
+     * ```
+     */
+    markMigrationFailure(input: {
+        /**
+         * Persisted migration record to mark failed or reconciling; completed cutover/rolled-back records cannot be changed through this method.
+         */
+        migrationId: string;
+        /**
+         * Optional expected active execution token; a truthy supplied value must match, while omission skips this token check.
+         */
+        executionId?: string;
+        /**
+         * Failure disposition to persist: failed permits explicit retry preparation, while reconciling requires operator outcome review before retry.
+         */
+        status: 'failed' | 'reconciling';
+        /**
+         * Nonblank diagnostic text up to 2048 characters, stored with a generated occurrence timestamp; exclude secrets and customer payloads.
+         */
+        message: string;
+    }): Promise<LifecyclePlatformMigrationRecord>;
+    /**
+     * Applies an operator reconciliation status action and records its note.
+     * @param input - Persisted migrationId, action, and nonblank note up to 2048 characters; retry only permits failed/reconciling state and clears execution/verification/cutover.
+     * @returns Cloned updated migration record.
+     * @throws Missing record, retry from an ineligible state, completed record for mark-failed/mark-reconciling, invalid text, or host store failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function reconcileMigration(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["reconcileMigration"]>) {
+     *   return store.reconcileMigration(...args);
+     * }
+     * ```
+     */
+    reconcileMigration(input: {
+        /**
+         * Persisted migration whose operator reconciliation state is being updated.
+         */
+        migrationId: string;
+        /**
+         * Explicit retry, mark-failed or mark-reconciling action; retry requires failed/reconciling state and clears execution, verification and cutover data.
+         */
+        action: PlatformMigrationReconcileAction;
+        /**
+         * Nonblank operator rationale up to 2048 characters, persisted as timestamped diagnostic text; this does not independently verify external outcomes.
+         */
+        note: string;
+    }): Promise<LifecyclePlatformMigrationRecord>;
+    /**
+     * Creates a reverse migration plan for a completed cutover without executing rollback.
+     * @param input - Verified tenantId, completed migrationId, nonblank reason up to 1024 characters, and parseable requestedAt timestamp.
+     * @returns New planned reverse migration linked to the original record.
+     * @throws Incomplete/already rollback-planned migration, tenant no longer on migrated target, invalid input/planning, or host store failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function createRollbackPlan(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["createRollbackPlan"]>) {
+     *   return store.createRollbackPlan(...args);
+     * }
+     * ```
+     */
+    createRollbackPlan(input: {
+        /**
+         * Verified tenant currently placed on the completed migration target; the current placement must still match before a reverse plan is created.
+         */
+        tenantId: string;
+        /**
+         * Completed cutover migration to reverse; an existing rollback plan prevents creating another one.
+         */
+        migrationId: string;
+        /**
+         * Nonblank rollback planning rationale up to 1024 characters, copied to the new reverse migration request.
+         */
+        reason: string;
+        /**
+         * Parseable rollback request timestamp copied to the new plan/status record; no rollback is executed by planning.
+         */
+        requestedAt: string;
+    }): Promise<BackendMigrationPlan>;
+    /**
+     * Commits a verified migration routing change and transfers active plugin activations to the target backend.
+     * @param input - Tenant included by the exact persisted plan and its previously recorded cutover proof.
+     * @returns New target placement, or current placement for an already-cutover record.
+     * @throws Unverified/stale/changed plan, invalid cutover or nonadvancing routing revision, target tenant mismatch, missing planned active plugin or target installation, or host lock/write failure.
+     * @example
+     * ```typescript
+     * import { LifecyclePlatformControlStore } from "@alneas/eaos-server/platform-admin/store";
+     * export async function recordTenantPlacement(store: LifecyclePlatformControlStore, ...args: Parameters<LifecyclePlatformControlStore["recordTenantPlacement"]>) {
+     *   return store.recordTenantPlacement(...args);
+     * }
+     * ```
+     */
+    recordTenantPlacement(input: {
+        /**
+         * Verified tenant included in the plan whose persisted routing placement and active plugin bindings will be moved.
+         */
+        tenantId: string;
+        /**
+         * Exact persisted verified migration plan; current source/target backend identities and installations are rechecked before commit.
+         */
+        plan: BackendMigrationPlan;
+        /**
+         * Previously recorded verification proof with source retained and an advancing routing revision; its canonical contents must match the saved cutover.
+         */
+        cutover: BackendMigrationCutover;
+    }): Promise<TenantBackendPlacement>;
+}
+
+export { LifecyclePlatformControlStore };

package/dist/platform-admin/store.js

@@ -0,0 +1,7 @@
+import {
+  LifecyclePlatformControlStore
+} from "../chunk-YMJ7BRKU.js";
+export {
+  LifecyclePlatformControlStore
+};
+//# sourceMappingURL=store.js.map

package/dist/platform-admin/store.js.map

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

package/dist/plugin-data/annotations.d.ts

@@ -0,0 +1,6 @@
+export { AnnotationTarget, ReaderComment, annotationOperations, annotationSchemas, documentAnnotations } from './index.js';
+import '@alneas/eaos-core';
+import 'hono/types';
+import '@alneas/eaos-core/plugin-sdk';
+import 'hono';
+import '@alneas/eaos-server/lifecycle-engine';

package/dist/plugin-data/annotations.js

@@ -0,0 +1,12 @@
+import {
+  annotationOperations,
+  annotationSchemas,
+  documentAnnotations
+} from "../chunk-INCHXAFK.js";
+import "../chunk-3VITSHN3.js";
+export {
+  annotationOperations,
+  annotationSchemas,
+  documentAnnotations
+};
+//# sourceMappingURL=annotations.js.map

package/dist/plugin-data/annotations.js.map

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

package/dist/plugin-data/atomic-context.d.ts

@@ -0,0 +1,41 @@
+import { AtomicSession, AtomicSqlConnection, PluginPrincipal, AtomicSqlDriver } from './index.js';
+import '@alneas/eaos-core';
+import 'hono/types';
+import '@alneas/eaos-core/plugin-sdk';
+import 'hono';
+import '@alneas/eaos-server/lifecycle-engine';
+
+/**
+ * Weak capability map joining validated session wrappers to their live SQL connection, principal and dialect; trusted adapter plumbing only.
+ *
+ *
+ * Internal capability propagation through validated session wrappers; never a new transaction.
+ * @see inheritAtomicSqlSession for canonical usage.
+ */
+declare const atomicSqlBindings: WeakMap<AtomicSession, {
+    /**
+     * Exact active SQL connection whose commit/rollback boundary owns this session.
+     */
+    connection: AtomicSqlConnection;
+    /**
+     * Verified tenant/user scope bound to this live connection.
+     */
+    principal: PluginPrincipal;
+    /**
+     * Trusted SQL dialect of the joined transaction driver.
+     */
+    dialect: AtomicSqlDriver["dialect"];
+}>;
+/**
+ * Temporarily propagate an existing joined SQL capability to a validated session wrapper.
+ * @param source - Currently bound source session; if unbound no capability is created.
+ * @param wrapper - Wrapper session whose lifetime must not exceed the parent callback.
+ * @returns A release callback deleting the wrapper's propagated binding.
+ * @remarks Internal trusted capability plumbing exposed for validated host adapters. It never opens a transaction, authenticates a principal or extends the underlying session lifetime.
+ * @example
+ * import { inheritAtomicSqlSession } from '@alneas/eaos-server/plugin-data/atomic-context'
+ * export function withBinding(source: Parameters<typeof inheritAtomicSqlSession>[0], wrapper: Parameters<typeof inheritAtomicSqlSession>[1], work: () => void) { const release = inheritAtomicSqlSession(source, wrapper); try { work() } finally { release() } }
+ */
+declare function inheritAtomicSqlSession(source: AtomicSession, wrapper: AtomicSession): () => void;
+
+export { atomicSqlBindings, inheritAtomicSqlSession };

package/dist/plugin-data/atomic-context.js

@@ -0,0 +1,9 @@
+import {
+  atomicSqlBindings,
+  inheritAtomicSqlSession
+} from "../chunk-3VITSHN3.js";
+export {
+  atomicSqlBindings,
+  inheritAtomicSqlSession
+};
+//# sourceMappingURL=atomic-context.js.map

package/dist/plugin-data/atomic-context.js.map

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

package/dist/plugin-data/atomic.d.ts

@@ -0,0 +1,6 @@
+export { AtomicRepository, AtomicRepositoryOptions, AtomicRow, AtomicSession, AtomicSqlConnection, AtomicSqlDriver, OracleAtomicConnection, OracleAtomicHost, SqliteAtomicDatabase, atomicCommand, atomicHash, createAtomicRecordStore, createAtomicRepository, createOracleAtomicDriver, createPluginAtomicRepository, createSqliteAtomicDriver, joinedAtomicSqlExecutor, parseRecordCursor, recordCursor } from './index.js';
+import '@alneas/eaos-server/lifecycle-engine';
+import '@alneas/eaos-core/plugin-sdk';
+import '@alneas/eaos-core';
+import 'hono/types';
+import 'hono';

package/dist/plugin-data/atomic.js

@@ -0,0 +1,26 @@
+import {
+  atomicCommand,
+  atomicHash,
+  createAtomicRecordStore,
+  createAtomicRepository,
+  createOracleAtomicDriver,
+  createPluginAtomicRepository,
+  createSqliteAtomicDriver,
+  joinedAtomicSqlExecutor,
+  parseRecordCursor,
+  recordCursor
+} from "../chunk-INCHXAFK.js";
+import "../chunk-3VITSHN3.js";
+export {
+  atomicCommand,
+  atomicHash,
+  createAtomicRecordStore,
+  createAtomicRepository,
+  createOracleAtomicDriver,
+  createPluginAtomicRepository,
+  createSqliteAtomicDriver,
+  joinedAtomicSqlExecutor,
+  parseRecordCursor,
+  recordCursor
+};
+//# sourceMappingURL=atomic.js.map

package/dist/plugin-data/atomic.js.map

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

package/dist/plugin-data/audit.d.ts

@@ -0,0 +1,6 @@
+export { AtomicAuditEvent, appendAtomicAudit, readAtomicAudit, verifyAtomicAudit } from './index.js';
+import '@alneas/eaos-core';
+import 'hono/types';
+import '@alneas/eaos-core/plugin-sdk';
+import 'hono';
+import '@alneas/eaos-server/lifecycle-engine';

package/dist/plugin-data/audit.js

@@ -0,0 +1,12 @@
+import {
+  appendAtomicAudit,
+  readAtomicAudit,
+  verifyAtomicAudit
+} from "../chunk-INCHXAFK.js";
+import "../chunk-3VITSHN3.js";
+export {
+  appendAtomicAudit,
+  readAtomicAudit,
+  verifyAtomicAudit
+};
+//# sourceMappingURL=audit.js.map

package/dist/plugin-data/audit.js.map

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