@alneas/eaos-server 0.0.0-stage → 0.2.0

package/dist/chunk-SDJNYPYK.js

@@ -0,0 +1,770 @@
+// src/lifecycle-engine/baseline.ts
+import { lt as lt2, valid as valid2, satisfies as satisfies2 } from "semver";
+
+// src/lifecycle-engine/index.ts
+import { dataContractTables, resolveDataContracts } from "@alneas/eaos-core/contracts/data-contracts";
+import { createHash } from "node:crypto";
+import { satisfies, valid, validRange, lt } from "semver";
+
+// package.json
+var version = "0.2.0";
+
+// src/lifecycle-engine/backend-migration.ts
+function text(value, name, max = 256) {
+  if (typeof value !== "string" || !value.trim() || value.length > max) throw new Error(`Invalid migration ${name}`);
+  return value;
+}
+function assertBackend(backend, name) {
+  if (!backend || typeof backend !== "object") throw new Error(`Invalid migration ${name}`);
+  text(backend?.id, `${name} id`);
+  text(backend?.databaseId, `${name} databaseId`);
+  if (!["sqlite", "postgres", "oracle"].includes(backend.dialect) || !["shared", "dedicated"].includes(backend.mode)) throw new Error(`Invalid migration ${name}`);
+  if (backend.mode === "dedicated" && !backend.tenantId) throw new Error(`Dedicated ${name} requires tenantId`);
+  if (backend.mode === "shared" && backend.tenantId !== void 0) throw new Error(`Shared ${name} cannot pin tenantId`);
+}
+function planBackendMigration(request) {
+  text(request?.migrationId, "migrationId");
+  text(request?.reason, "reason", 1024);
+  if (!Number.isFinite(Date.parse(request.requestedAt))) throw new Error("Invalid migration requestedAt");
+  assertBackend(request.source, "source backend");
+  assertBackend(request.target, "target backend");
+  if (request.source.id === request.target.id || request.source.databaseId === request.target.databaseId) throw new Error("Backend migration requires a different physical database");
+  if (!Array.isArray(request.pluginIds) || request.pluginIds.length === 0 || new Set(request.pluginIds).size !== request.pluginIds.length || request.pluginIds.some((id2) => !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(id2))) throw new Error("Invalid migration pluginIds");
+  if (!request.scope || typeof request.scope !== "object" || !["all-tenants", "tenants"].includes(request.scope.kind)) throw new Error("Invalid migration scope");
+  if (request.scope.kind === "tenants" && (!Array.isArray(request.scope.tenantIds) || request.scope.tenantIds.length === 0 || new Set(request.scope.tenantIds).size !== request.scope.tenantIds.length || request.scope.tenantIds.some((id2) => !/^\S{1,256}$/.test(id2)))) throw new Error("Invalid migration tenant scope");
+  const scope = request.scope.kind === "all-tenants" ? request.scope : { kind: "tenants", tenantIds: [...request.scope.tenantIds].sort() };
+  const scopedTenants = scope.kind === "tenants" ? scope.tenantIds : null;
+  if (request.source.mode === "dedicated" && (!scopedTenants || !scopedTenants.includes(request.source.tenantId))) throw new Error("Migration scope does not include the dedicated source tenant");
+  if (request.target.mode === "dedicated" && (!scopedTenants || !scopedTenants.includes(request.target.tenantId))) throw new Error("Migration scope does not include the dedicated target tenant");
+  const normalized = structuredClone({ ...request, pluginIds: [...request.pluginIds].sort(), scope });
+  const body = { format: 1, request: normalized, phases: ["prepare", "copy", "verify", "cutover", "retain-source"], requiresQuiesce: true, retainSourceData: true, destructiveOperations: false };
+  return Object.freeze({ ...body, id: lifecycleDigest(body) });
+}
+function assertBackendMigrationVerification(plan, report) {
+  if (!report || report.migrationId !== plan.request.migrationId || report.sourceBackendId !== plan.request.source.id || report.targetBackendId !== plan.request.target.id || !Number.isFinite(Date.parse(report.checkedAt)) || report.passed !== true || !Array.isArray(report.records) || report.records.length === 0) throw new Error("Backend migration verification is incomplete");
+  const tenants = plan.request.scope.kind === "tenants" ? new Set(plan.request.scope.tenantIds) : null;
+  for (const record of report.records) {
+    if (!record || typeof record.tenantId !== "string" || tenants && !tenants.has(record.tenantId) || !plan.request.pluginIds.includes(record.pluginId) || !Number.isSafeInteger(record.sourceRevision) || record.sourceRevision < 0 || !Number.isSafeInteger(record.targetRevision) || record.targetRevision < 0 || record.matched !== true) throw new Error("Backend migration verification is incomplete");
+  }
+  return report;
+}
+function assertBackendMigrationCutover(plan, report, cutover) {
+  assertBackendMigrationVerification(plan, report);
+  if (!cutover || cutover.migrationId !== plan.request.migrationId || cutover.targetBackendId !== plan.request.target.id || cutover.sourceRetained !== true || !Number.isSafeInteger(cutover.routingRevision) || cutover.routingRevision < 0 || !Number.isFinite(Date.parse(cutover.cutoverAt))) throw new Error("Backend migration cutover is invalid");
+  return cutover;
+}
+
+// src/lifecycle-engine/index.ts
+export * from "@alneas/eaos-core/contracts/data-contracts";
+import { dataContractTables as dataContractTables2, resolveDataContracts as resolveDataContracts2, assertDataContractBinding, collectSchemaMigrations, createJsonDocumentAssertion, assertJsonDocumentContracts } from "@alneas/eaos-core/contracts/data-contracts";
+var FRAMEWORK_VERSION = version;
+var emptyLifecyclePlatformState = () => ({ tenants: {}, placements: {}, backendMetadata: {}, migrationPlans: {}, migrationRecords: {} });
+var emptyLifecycleState = () => ({ format: 1, revision: 0, backends: {}, installations: {}, activations: {}, migrations: {}, infrastructure: {}, platform: emptyLifecyclePlatformState() });
+function normalizeLifecycleState(input) {
+  if (!input || typeof input !== "object") throw new Error("Invalid lifecycle state");
+  const state = structuredClone(input);
+  if (state.platform === void 0) state.platform = emptyLifecyclePlatformState();
+  if (!state.platform || typeof state.platform !== "object" || Array.isArray(state.platform)) throw new Error("Invalid lifecycle platform state");
+  for (const field of ["tenants", "placements", "backendMetadata", "migrationPlans", "migrationRecords"]) {
+    if (state.platform[field] === void 0) state.platform[field] = {};
+    if (!state.platform[field] || typeof state.platform[field] !== "object" || Array.isArray(state.platform[field])) throw new Error(`Invalid lifecycle platform ${field}`);
+  }
+  return state;
+}
+function canonical(value) {
+  if (value === null || typeof value !== "object") {
+    const result = JSON.stringify(value);
+    if (result === void 0) throw new Error("Lifecycle configuration must be JSON serializable");
+    return result;
+  }
+  if (Array.isArray(value)) return "[" + value.map(canonical).join(",") + "]";
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new Error("Lifecycle configuration must contain plain objects");
+  return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + canonical(value[k])).join(",") + "}";
+}
+var lifecycleDigest = (value) => createHash("sha256").update(canonical(value)).digest("hex");
+var key = (...parts) => JSON.stringify(parts);
+function id(value) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(value)) throw new Error("Invalid lifecycle identifier");
+}
+function assertState(s) {
+  if (s?.format !== 1 || !Number.isSafeInteger(s.revision) || s.revision < 0 || !s.backends || !s.installations || !s.activations || !s.migrations || !s.infrastructure) throw new Error("Invalid lifecycle state");
+  if (s.dataContracts !== void 0) {
+    if (!s.dataContracts || typeof s.dataContracts !== "object" || Array.isArray(s.dataContracts)) throw new Error("Invalid data contract state");
+    for (const [recordKey, record] of Object.entries(s.dataContracts)) {
+      const parts = JSON.parse(recordKey);
+      if (!Array.isArray(parts) || parts.length !== 2 || parts[1] !== record.contract?.id || record.digest !== lifecycleDigest(record.contract) || !["installing", "installed", "failed"].includes(record.status)) throw new Error("Invalid data contract state record");
+    }
+  }
+}
+var PluginLifecycle = class {
+  /**
+   * Validates and snapshots the registered plugin, backend, contract and bundle catalogs.
+   * @param project - Host lifecycle storage, trusted catalogs and execution adapters.
+   * @param frameworkVersion - Valid semver framework version; defaults to the installed package version.
+   * @throws Error for invalid/duplicate IDs, versions, migrations, conflicting schemas, unsupported backend configuration or unsatisfied contract dependencies.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle, type LifecycleProject } from '@alneas/eaos-server/lifecycle-engine';
+   * export function connectLifecycle(project: LifecycleProject) { return new PluginLifecycle(project); }
+   * ```
+   */
+  constructor(project, frameworkVersion = FRAMEWORK_VERSION) {
+    this.project = project;
+    this.frameworkVersion = frameworkVersion;
+    if (!valid(frameworkVersion)) throw new Error("Invalid framework version");
+    const plugins = JSON.parse(canonical(project.plugins));
+    const backends = JSON.parse(canonical(project.backends));
+    this.plugins = /* @__PURE__ */ new Map();
+    this.backends = /* @__PURE__ */ new Map();
+    for (const p of plugins) {
+      id(p.id);
+      if (this.plugins.has(p.id) || !valid(p.version) || !validRange(p.framework)) throw new Error("Invalid or duplicate plugin release");
+      if ((project.dataContracts !== void 0 || Object.keys(p.schemaDependencies ?? {}).length) && p.migrations.length) throw new Error(`Contract-backed plugin must put DDL in data contracts: ${p.id}`);
+      const migrations = /* @__PURE__ */ new Set();
+      for (const m of p.migrations) {
+        id(m.id);
+        if (migrations.has(m.id) || !["database", "tenant"].includes(m.scope)) throw new Error("Invalid or duplicate migration");
+        for (const sql of Object.values(m.sql)) if (!Array.isArray(sql) || !sql.length || sql.some((s) => typeof s !== "string" || !s.trim())) throw new Error("Invalid migration SQL");
+        migrations.add(m.id);
+      }
+      const release = { ...p };
+      delete release.schemaContracts;
+      this.plugins.set(p.id, release);
+    }
+    const contracts = /* @__PURE__ */ new Map();
+    for (const contract of [...project.dataContracts ?? [], ...plugins.flatMap((p) => p.schemaContracts ?? [])]) {
+      const previous = contracts.get(contract.id);
+      if (previous && canonical(previous) !== canonical(contract)) throw new Error(`Conflicting data contract definitions: ${contract.id}`);
+      contracts.set(contract.id, JSON.parse(canonical(contract)));
+    }
+    this.contracts = [...contracts.values()];
+    resolveDataContracts(this.contracts, Object.fromEntries(this.contracts.map((c) => [c.id, c.version])));
+    for (const p of plugins) this.catalog([p]);
+    for (const [bundleId, pluginIds] of Object.entries(project.bundles ?? {})) {
+      id(bundleId);
+      if (!Array.isArray(pluginIds) || !pluginIds.length || new Set(pluginIds).size !== pluginIds.length || pluginIds.some((pluginId) => !this.plugins.has(pluginId))) throw new Error(`Invalid plugin bundle: ${bundleId}`);
+    }
+    for (const b of backends) {
+      id(b.id);
+      id(b.databaseId);
+      if (this.backends.has(b.id) || !["sqlite", "oracle", "postgres"].includes(b.dialect) || !["shared", "dedicated"].includes(b.mode)) throw new Error("Invalid backend target");
+      if (b.mode === "dedicated") {
+        if (!b.tenantId) throw new Error("Dedicated backend requires tenant");
+        id(b.tenantId);
+      } else if (b.tenantId !== void 0) throw new Error("Shared backend cannot bind a tenant");
+      for (const other of backends) if (other.databaseId === b.databaseId && other.dialect !== b.dialect) throw new Error("Database dialect conflict");
+      this.backends.set(b.id, b);
+    }
+  }
+  project;
+  frameworkVersion;
+  plugins;
+  backends;
+  contracts;
+  bundle(bundleId) {
+    id(bundleId);
+    const pluginIds = this.project.bundles?.[bundleId];
+    if (!pluginIds) throw new Error(`Plugin bundle not registered: ${bundleId}`);
+    return pluginIds;
+  }
+  /**
+   * Plans registered bundle members sequentially against a projected ledger state.
+   * @param request - Lifecycle request whose pluginId names a registered bundle.
+   * @returns A checksum-bound ordered bundle plan with each member's projected revision.
+   * @throws Rejects unknown bundle, invalid member request/state or propagated store failures.
+   * 
+   * @remarks
+   * Disable/uninstall reverse bundle order. Planning executes no migrations or writes; projected revisions mirror member apply ordering.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle, type LifecycleRequest } from '@alneas/eaos-server/lifecycle-engine';
+   * export function reviewBundle(lifecycle: PluginLifecycle, request: LifecycleRequest) { return lifecycle.planBundle(request); }
+   * ```
+   */
+  async planBundle(request) {
+    const pluginIds = [...this.bundle(request.pluginId)];
+    if (request.operation === "disable" || request.operation === "uninstall") pluginIds.reverse();
+    let projected = await this.project.store.read();
+    const plans = [];
+    for (const pluginId of pluginIds) {
+      const plan = this.makePlan({ ...request, pluginId }, projected);
+      plans.push(plan);
+      projected = this.projectBundleState(projected, plan);
+    }
+    const body = { format: 1, bundleId: request.pluginId, operation: request.operation, plans };
+    return JSON.parse(canonical({ ...body, id: lifecycleDigest(body) }));
+  }
+  /**
+   * Advance the read-only state used while constructing sequential bundle plans.
+   * apply() performs these writes in the same order; mirroring them here keeps
+   * each plan's revision and dependency closure valid when applyBundle() runs.
+   */
+  projectBundleState(source, plan) {
+    const state = structuredClone(source);
+    state.backends[plan.backend.id] = plan.backend;
+    for (const k of plan.deactivate) if (state.activations[k]) state.activations[k].enabled = false;
+    if (plan.request.operation === "install" || plan.request.operation === "update") {
+      for (const plugin of plan.plugins) state.installations[key(plan.backend.id, plugin.id)] = { release: plugin, digest: lifecycleDigest(plugin), status: "installed" };
+      if (plan.dataCatalog) {
+        state.dataContracts ??= {};
+        for (const contract of plan.dataCatalog.contracts) state.dataContracts[key(plan.backend.databaseId, contract.id)] = { contract, digest: lifecycleDigest(contract), status: "installed" };
+      }
+      for (const step of plan.migrations) state.migrations[step.key] = { ...step.record, status: "applied" };
+      for (const step of plan.infrastructure) state.infrastructure[step.key] = { digest: step.digest, status: "applied" };
+      state.revision += 2 + plan.migrations.length * 2 + plan.infrastructure.length * 2;
+    } else if (plan.request.operation === "enable") {
+      for (const plugin of plan.plugins) state.activations[key(plan.backend.id, plan.request.tenantId, plugin.id)] = { backendId: plan.backend.id, tenantId: plan.request.tenantId, pluginId: plugin.id, digest: lifecycleDigest(plugin), enabled: true };
+      state.revision += 1;
+    } else if (plan.request.operation === "uninstall") {
+      delete state.installations[key(plan.backend.id, plan.request.pluginId)];
+      state.revision += 1;
+    } else {
+      state.revision += 1;
+    }
+    return state;
+  }
+  /**
+   * Validates a reviewed bundle plan and applies its member plans in sequence.
+   * @param bundlePlan - Unmodified checksum-bound bundle plan from planBundle.
+   * @returns Resolves without a value after every member apply completes.
+   * @throws Rejects modified/stale/misordered bundle plans, member apply failures and propagated host errors.
+   * 
+   * @remarks
+   * Members acquire their own ledger locks. There is no all-or-nothing bundle transaction; earlier members remain applied if a later member fails. Replan/reconcile before retrying uncertain outcomes.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle, type LifecycleBundlePlan } from '@alneas/eaos-server/lifecycle-engine';
+   * export function applyReviewedBundle(lifecycle: PluginLifecycle, plan: LifecycleBundlePlan) { return lifecycle.applyBundle(plan); }
+   * ```
+   */
+  async applyBundle(bundlePlan) {
+    const normalized = JSON.parse(canonical(bundlePlan));
+    const pluginIds = this.bundle(normalized.bundleId);
+    const expectedIds = normalized.operation === "disable" || normalized.operation === "uninstall" ? [...pluginIds].reverse() : [...pluginIds];
+    if (normalized.format !== 1 || !["install", "update", "enable", "disable", "uninstall"].includes(normalized.operation) || normalized.plans.length !== expectedIds.length || normalized.plans.some((plan, index) => plan.request.pluginId !== expectedIds[index] || plan.request.operation !== normalized.operation)) throw new Error("Invalid plugin bundle plan");
+    const body = { format: 1, bundleId: normalized.bundleId, operation: normalized.operation, plans: normalized.plans };
+    if (lifecycleDigest(body) !== normalized.id) throw new Error("Stale or modified plugin bundle plan");
+    for (const plan of normalized.plans) await this.apply(plan);
+  }
+  release(id2) {
+    const p = this.plugins.get(id2);
+    if (!p) throw new Error(`Plugin code not registered: ${id2}`);
+    if (!satisfies(this.frameworkVersion, p.framework, { includePrerelease: true })) throw new Error(`Incompatible framework for ${id2}`);
+    return p;
+  }
+  order(pluginId) {
+    const ordered = [], visited = /* @__PURE__ */ new Set(), visiting = /* @__PURE__ */ new Set();
+    const visit = (id2) => {
+      if (visiting.has(id2)) throw new Error("Plugin dependency cycle");
+      if (visited.has(id2)) return;
+      visiting.add(id2);
+      const p = this.release(id2);
+      for (const [dependency, range] of Object.entries(p.dependencies ?? {})) {
+        if (!validRange(range) || !satisfies(this.release(dependency).version, range, { includePrerelease: true })) throw new Error(`Unsatisfied dependency: ${dependency}`);
+        visit(dependency);
+      }
+      visiting.delete(id2);
+      visited.add(id2);
+      ordered.push(p);
+    };
+    visit(pluginId);
+    return ordered;
+  }
+  /**
+   * Resolves the canonical schema dependency catalog for registered feature plugins.
+   * 
+   * Read-only complete schema inventory for the selected trusted feature catalog.
+   * @param pluginIds - Optional feature IDs; omitted includes all registered plugins, while an empty array selects none.
+   * @returns A JSON-cloned dependency-resolved DataContractCatalog.
+   * @throws Error for unknown/incompatible feature dependencies or invalid/conflicting contract requirements.
+   * 
+   * @remarks
+   * Read-only; schema dependencies never install or enable feature plugins.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle } from '@alneas/eaos-server/lifecycle-engine';
+   * export function schemas(lifecycle: PluginLifecycle) { return lifecycle.schemaCatalog(); }
+   * ```
+   */
+  schemaCatalog(pluginIds) {
+    const plugins = pluginIds ? pluginIds.flatMap((id2) => this.order(id2)) : [...this.plugins.values()];
+    return JSON.parse(canonical(this.catalog(plugins)));
+  }
+  catalog(plugins) {
+    const requirements = {};
+    for (const plugin of plugins) {
+      resolveDataContracts(this.contracts, plugin.schemaDependencies ?? {});
+      Object.assign(requirements, plugin.schemaDependencies ?? {});
+    }
+    return resolveDataContracts(this.contracts, requirements);
+  }
+  contractReady(state, backend, tenantId, contract) {
+    const installed = state.dataContracts?.[key(backend.databaseId, contract.id)];
+    if (installed?.status !== "installed" || installed.digest !== lifecycleDigest(contract)) return false;
+    const identity = contract.migrationIdentity ?? `data-${contract.id}`;
+    return contract.migrations.every((m) => {
+      const record = state.migrations[key(backend.databaseId, identity, m.id, m.scope === "tenant" ? tenantId : "*")];
+      return record?.status === "applied" && record.checksum === lifecycleDigest(m);
+    });
+  }
+  /** Contract ledger identities may retain a feature's historical name even
+   * when that feature no longer consumes the contract. Match the actual
+   * immutable migration, rather than only the current feature's catalog. */
+  isContractMigration(record) {
+    return this.contracts.some((contract) => {
+      if ((contract.migrationIdentity ?? `data-${contract.id}`) !== record.pluginId) return false;
+      const migration = contract.migrations[record.position];
+      return !!migration && migration.id === record.migrationId && lifecycleDigest(migration) === record.checksum && record.status === "applied";
+    });
+  }
+  target(request) {
+    id(request.pluginId);
+    id(request.backendId);
+    id(request.tenantId);
+    if (!["install", "update", "enable", "disable", "uninstall"].includes(request.operation)) throw new Error("Invalid lifecycle operation");
+    const b = this.backends.get(request.backendId);
+    if (!b || b.mode === "dedicated" && b.tenantId !== request.tenantId) throw new Error("Backend tenant mismatch or unknown backend");
+    return b;
+  }
+  /**
+   * Creates a reviewable lifecycle plan from one current ledger snapshot without executing side effects.
+   * @param request - Concrete operation, registered plugin/backend and verified tenant; see LifecycleRequest.
+   * @returns A deterministic checksum-bound plan carrying the snapshot revision, dependency closure, migrations and retained-data policy.
+   * @throws Rejects invalid request/state, incompatible or missing dependencies, changed applied migrations, dirty ledger, unsupported dialect, tenant mismatch or propagated store failures.
+   * 
+   * @remarks
+   * Planning is read-only but may become stale immediately. Backend physical identity is immutable. Updates require appended immutable migrations and compatible schema versions; installation and enablement are separate operations.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle, type LifecycleRequest } from '@alneas/eaos-server/lifecycle-engine';
+   * export function review(lifecycle: PluginLifecycle, request: LifecycleRequest) { return lifecycle.plan(request); }
+   * ```
+   */
+  async plan(request) {
+    return this.makePlan(request, await this.project.store.read());
+  }
+  makePlan(request, state) {
+    assertState(state);
+    const backend = this.target(request), operation = request.operation;
+    if (state.backends[backend.id] && canonical(state.backends[backend.id]) !== canonical(backend)) throw new Error("Backend placement is immutable; use a new backend ID and migrate data explicitly");
+    for (const b of Object.values(state.backends)) if (b.databaseId === backend.databaseId && b.dialect !== backend.dialect) throw new Error("Database dialect conflict");
+    const changing = operation === "install" || operation === "update";
+    const installed = state.installations[key(backend.id, request.pluginId)];
+    const plugins = changing || operation === "enable" ? this.order(request.pluginId) : [installed?.release ?? this.plugins.get(request.pluginId)].filter(Boolean);
+    if (!plugins.length) throw new Error("Plugin is not installed");
+    if (operation === "update" && !installed) throw new Error("Install plugin before updating");
+    const dataCatalog = this.catalog(plugins);
+    for (const table of dataCatalog.tables) {
+      for (const [contractKey, installation] of Object.entries(state.dataContracts ?? {})) {
+        if (JSON.parse(contractKey)[0] !== backend.databaseId) continue;
+        if (installation.contract.id !== table.contractId && dataContractTables(installation.contract.schema).has(table.name)) throw new Error(`Installed data contract already owns table: ${table.name}`);
+      }
+    }
+    const migrations = [], infrastructure = [], deactivate = /* @__PURE__ */ new Set();
+    const markDependents = (backendId, pluginId) => {
+      const affected = /* @__PURE__ */ new Set([pluginId]);
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const [k, entry] of Object.entries(state.installations)) {
+          if (JSON.parse(k)[0] !== backendId || affected.has(entry.release.id)) continue;
+          if (Object.keys(entry.release.dependencies ?? {}).some((d) => affected.has(d))) {
+            affected.add(entry.release.id);
+            changed = true;
+          }
+        }
+      }
+      for (const [k, a] of Object.entries(state.activations)) if (a.backendId === backendId && affected.has(a.pluginId)) deactivate.add(k);
+    };
+    if (changing) for (const contract of dataCatalog.contracts) {
+      const identity = contract.migrationIdentity ?? `data-${contract.id}`;
+      const old = state.dataContracts?.[key(backend.databaseId, contract.id)];
+      if (old && old.status !== "installed") throw new Error(`Data contract requires reconciliation: ${contract.id}`);
+      if (old && old.digest !== lifecycleDigest(contract)) {
+        if (old.contract.version === contract.version) throw new Error(`Data contract changed without version bump: ${contract.id}`);
+        if (lt(contract.version, old.contract.version)) throw new Error("Data contract downgrade requires explicit migration");
+        if (canonical(contract.schema) !== canonical(old.contract.schema) && contract.migrations.length <= old.contract.migrations.length) throw new Error(`Schema changed without an appended migration: ${contract.id}`);
+      }
+      for (const [installationKey, installation] of Object.entries(state.installations)) {
+        if (state.backends[JSON.parse(installationKey)[0]]?.databaseId !== backend.databaseId) continue;
+        const range = installation.release.schemaDependencies?.[contract.id];
+        if (range && !satisfies(contract.version, range)) throw new Error(`Installed plugin requires incompatible data contract: ${installation.release.id}`);
+      }
+      for (const record of Object.values(state.migrations).filter((m) => m.databaseId === backend.databaseId && m.pluginId === identity)) {
+        const m = contract.migrations[record.position];
+        if (!m || m.id !== record.migrationId || lifecycleDigest(m) !== record.checksum) throw new Error(`Applied contract migration changed or removed: ${record.migrationId}`);
+        if (record.status !== "applied") throw new Error(`Data contract migration requires reconciliation: ${record.migrationId}`);
+      }
+      for (const [position, m] of contract.migrations.entries()) {
+        const statements = m.sql[backend.dialect];
+        if (!statements?.length) throw new Error(`Data contract migration ${m.id} does not support ${backend.dialect}`);
+        const tenantId = m.scope === "tenant" ? request.tenantId : null;
+        const k = key(backend.databaseId, identity, m.id, tenantId ?? "*");
+        if (!state.migrations[k]) migrations.push({ key: k, record: { databaseId: backend.databaseId, pluginId: identity, migrationId: m.id, position, tenantId, checksum: lifecycleDigest(m), status: "running" }, statements });
+      }
+      if (!old || old.digest !== lifecycleDigest(contract) || contract.migrations.some((m) => !state.migrations[key(backend.databaseId, identity, m.id, m.scope === "tenant" ? request.tenantId : "*")])) {
+        for (const activation of Object.values(state.activations)) {
+          if (state.backends[activation.backendId]?.databaseId !== backend.databaseId) continue;
+          const release = state.installations[key(activation.backendId, activation.pluginId)]?.release;
+          if (release && this.catalog([release]).contracts.some((c) => c.id === contract.id)) markDependents(activation.backendId, activation.pluginId);
+        }
+      }
+    }
+    if (changing) for (const p of plugins) {
+      const digest = lifecycleDigest(p), old = state.installations[key(backend.id, p.id)];
+      if (old && old.status !== "installed") throw new Error(`Installation requires reconciliation: ${p.id}`);
+      if (old && old.digest !== digest) {
+        if (old.release.version === p.version) throw new Error(`Release changed without version bump: ${p.id}`);
+        if (lt(p.version, old.release.version)) throw new Error("Plugin downgrade requires an explicit data migration");
+        if (operation === "install") throw new Error("Use update for an existing release");
+        markDependents(backend.id, p.id);
+      }
+      for (const record of Object.values(state.migrations).filter((m) => m.databaseId === backend.databaseId && m.pluginId === p.id && !this.isContractMigration(m))) {
+        const m = p.migrations.find((m2) => m2.id === record.migrationId);
+        if (!m || p.migrations.indexOf(m) !== record.position || lifecycleDigest(m) !== record.checksum) throw new Error(`Applied migration changed or removed: ${record.migrationId}`);
+        if (record.status !== "applied") throw new Error(`Migration requires reconciliation: ${record.migrationId}`);
+      }
+      for (const m of p.migrations) {
+        const statements = m.sql[backend.dialect];
+        if (!statements?.length) throw new Error(`Migration ${m.id} does not support ${backend.dialect}`);
+        const tenantId = m.scope === "tenant" ? request.tenantId : null;
+        const k = key(backend.databaseId, p.id, m.id, tenantId ?? "*");
+        if (!state.migrations[k]) {
+          migrations.push({ key: k, record: { databaseId: backend.databaseId, pluginId: p.id, migrationId: m.id, position: p.migrations.indexOf(m), tenantId, checksum: lifecycleDigest(m), status: "running" }, statements });
+          if (m.scope === "database") {
+            for (const b of Object.values(state.backends)) if (b.databaseId === backend.databaseId) markDependents(b.id, p.id);
+          }
+        }
+      }
+      if (p.infrastructure) {
+        const k = key(backend.id, p.id), digest2 = lifecycleDigest({ backend, plugin: p });
+        if (state.infrastructure[k] && state.infrastructure[k].status !== "applied") throw new Error("Infrastructure requires reconciliation");
+        if (state.infrastructure[k]?.digest !== digest2) infrastructure.push({ key: k, digest: digest2, plugin: p, backend });
+      }
+    }
+    if (operation === "disable" || operation === "uninstall") {
+      const dependents = Object.values(state.activations).filter((a) => a.backendId === backend.id && a.tenantId === request.tenantId && a.enabled && a.pluginId !== request.pluginId && this.dependsOn(state, backend.id, a.pluginId, request.pluginId));
+      if (dependents.length) throw new Error("Disable dependent plugins first");
+      const activation = key(backend.id, request.tenantId, request.pluginId);
+      if (operation === "disable") deactivate.add(activation);
+      else {
+        if (Object.values(state.activations).some((a) => a.backendId === backend.id && a.pluginId === request.pluginId && a.enabled)) throw new Error("Disable plugin for every tenant on this backend before uninstalling");
+        if (Object.entries(state.installations).some(([k, i]) => JSON.parse(k)[0] === backend.id && i.release.id !== request.pluginId && this.dependsOn(state, backend.id, i.release.id, request.pluginId))) throw new Error("Uninstall dependent plugins first");
+      }
+    }
+    if (operation === "enable") {
+      for (const p of plugins) if (!this.ready(state, backend, request.tenantId, p)) throw new Error(`Install/migrate compatible release before enabling: ${p.id}`);
+    }
+    const body = { format: 1, revision: state.revision, frameworkVersion: this.frameworkVersion, request: { ...request }, backend, ...dataCatalog.contracts.length ? { dataCatalog } : {}, plugins, migrations, infrastructure, deactivate: [...deactivate].sort(), infrastructureProvider: this.project.infrastructure?.identity ?? null, retainData: true };
+    return JSON.parse(canonical({ ...body, id: lifecycleDigest(body) }));
+  }
+  dependsOn(state, backendId, pluginId, target, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(pluginId)) return false;
+    seen.add(pluginId);
+    return Object.keys(state.installations[key(backendId, pluginId)]?.release.dependencies ?? {}).some((d) => d === target || this.dependsOn(state, backendId, d, target, seen));
+  }
+  ready(state, backend, tenantId, p) {
+    const installed = state.installations[key(backend.id, p.id)];
+    if (installed?.status !== "installed" || installed.digest !== lifecycleDigest(p)) return false;
+    if (Object.values(state.migrations).some((m) => m.databaseId === backend.databaseId && m.pluginId === p.id && !this.isContractMigration(m) && (m.status !== "applied" || !p.migrations.some((definition) => definition.id === m.migrationId && p.migrations.indexOf(definition) === m.position && lifecycleDigest(definition) === m.checksum)))) return false;
+    return this.catalog([p]).contracts.every((c) => this.contractReady(state, backend, tenantId, c)) && p.migrations.every((m) => {
+      const record = state.migrations[key(backend.databaseId, p.id, m.id, m.scope === "tenant" ? tenantId : "*")];
+      return record?.status === "applied" && record.checksum === lifecycleDigest(m);
+    }) && (!p.infrastructure || state.infrastructure[key(backend.id, p.id)]?.digest === lifecycleDigest({ backend, plugin: p }) && state.infrastructure[key(backend.id, p.id)]?.status === "applied");
+  }
+  /**
+   * Checks that a tenant activation and its entire registered dependency closure match ready ledger releases.
+   * @param backendId - Registered execution backend ID.
+   * @param tenantId - Verified concrete tenant ID.
+   * @param pluginId - Registered feature ID to check.
+   * @returns True only when matching installation, migrations, infrastructure and activation digests are all ready; false for missing/incompatible readiness.
+   * @throws Rejects malformed IDs/state, unknown or mismatched backend/tenant and store failures.
+   * 
+   * @remarks
+   * Read-only admission check; a later state change can revoke access. Host must still enforce current tenant/resource authorization.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle } from '@alneas/eaos-server/lifecycle-engine';
+   * export function admitted(lifecycle: PluginLifecycle, backendId: string, tenantId: string, pluginId: string) { return lifecycle.isEnabled(backendId, tenantId, pluginId); }
+   * ```
+   */
+  async isEnabled(backendId, tenantId, pluginId) {
+    const state = await this.project.store.read();
+    assertState(state);
+    return this.enabledInState(state, backendId, tenantId, pluginId);
+  }
+  enabledInState(state, backendId, tenantId, pluginId) {
+    const backend = this.target({ operation: "enable", backendId, tenantId, pluginId });
+    if (!state.backends[backend.id] || canonical(state.backends[backend.id]) !== canonical(backend)) return false;
+    let plugins;
+    try {
+      plugins = this.order(pluginId);
+    } catch {
+      return false;
+    }
+    return plugins.every((p) => this.ready(state, backend, tenantId, p) && state.activations[key(backendId, tenantId, p.id)]?.enabled === true && state.activations[key(backendId, tenantId, p.id)]?.digest === lifecycleDigest(p));
+  }
+  /**
+   * Reads inventory including registered uninstalled code and orphaned historical installations.
+   * 
+   * One read-only control-state snapshot; includes orphaned installation records and registered, uninstalled code.
+   * @param options - Optional backendId and tenantId filters; omitted returns all known inventory.
+   * @returns A revision-bound inventory with effective enabled state distinct from requested activation.
+   * @throws Rejects invalid filter IDs, unknown backend, corrupt installation/activation records, dedicated tenant mismatch or store failure.
+   * 
+   * @remarks
+   * Performs one ledger read without writes. Dedicated backends for another tenant are omitted unless explicitly requested, in which case the request rejects.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle } from '@alneas/eaos-server/lifecycle-engine';
+   * export function inventory(lifecycle: PluginLifecycle) { return lifecycle.list(); }
+   * ```
+   */
+  async list(options = {}) {
+    if (options.backendId !== void 0) id(options.backendId);
+    if (options.tenantId !== void 0) id(options.tenantId);
+    const state = await this.project.store.read();
+    assertState(state);
+    const installations = Object.entries(state.installations).map(([entryKey, installation]) => {
+      const parts = JSON.parse(entryKey);
+      if (!Array.isArray(parts) || parts.length !== 2 || parts.some((p) => typeof p !== "string")) throw new Error("Invalid installation key");
+      const [backendId, pluginId] = parts;
+      id(backendId);
+      id(pluginId);
+      if (installation.release?.id !== pluginId || !valid(installation.release.version) || !["installing", "installed", "failed"].includes(installation.status)) throw new Error("Invalid installation record");
+      return { backendId, pluginId };
+    });
+    const activations = Object.values(state.activations);
+    const backendIds = /* @__PURE__ */ new Set([...this.backends.keys(), ...Object.keys(state.backends), ...installations.map((p) => p.backendId), ...activations.map((p) => p.backendId)]);
+    for (const backendId of backendIds) id(backendId);
+    for (const activation of activations) {
+      id(activation.tenantId);
+      id(activation.pluginId);
+      if (typeof activation.enabled !== "boolean") throw new Error("Invalid activation record");
+    }
+    if (options.backendId && !backendIds.has(options.backendId)) throw new Error(`Unknown backend: ${options.backendId}`);
+    const targets = options.backendId ? [options.backendId] : backendIds.size ? [...backendIds].sort() : [null];
+    const plugins = [];
+    for (const backendId of targets) {
+      const backend = backendId ? this.backends.get(backendId) : void 0;
+      if (options.tenantId && backend?.mode === "dedicated" && backend.tenantId !== options.tenantId) {
+        if (options.backendId) throw new Error("Tenant does not belong to dedicated backend");
+        continue;
+      }
+      const pluginIds = /* @__PURE__ */ new Set([...this.plugins.keys(), ...installations.filter((p) => p.backendId === backendId).map((p) => p.pluginId), ...activations.filter((p) => p.backendId === backendId).map((p) => p.pluginId)]);
+      for (const pluginId of [...pluginIds].sort()) {
+        const registered = this.plugins.get(pluginId);
+        const installed = backendId ? state.installations[key(backendId, pluginId)] : void 0;
+        const tenantIds = options.tenantId ? [options.tenantId] : [...new Set(activations.filter((p) => p.backendId === backendId && p.pluginId === pluginId).map((p) => p.tenantId))].sort();
+        plugins.push({
+          pluginId,
+          backendId,
+          backendConfigured: !!backend,
+          registeredVersion: registered?.version ?? null,
+          installedVersion: installed?.release.version ?? null,
+          installationStatus: installed?.status ?? "not-installed",
+          releaseMatches: installed ? !!registered && installed.digest === lifecycleDigest(registered) : null,
+          tenants: tenantIds.map((tenantId) => ({
+            tenantId,
+            requestedEnabled: backendId ? state.activations[key(backendId, tenantId, pluginId)]?.enabled === true : false,
+            enabled: !!backend && !!backendId && (backend.mode !== "dedicated" || backend.tenantId === tenantId) && this.enabledInState(state, backendId, tenantId, pluginId)
+          }))
+        });
+      }
+    }
+    return { format: 1, revision: state.revision, frameworkVersion: this.frameworkVersion, plugins };
+  }
+  /**
+   * Runs a host callback only after the current plugin dependency closure passes lifecycle admission.
+   * @typeParam T - Value resolved by the admitted callback.
+   * @param backendId - Registered backend ID.
+   * @param tenantId - Verified concrete tenant ID.
+   * @param pluginId - Feature plugin ID.
+   * @param callback - Async work invoked once after admission; must enforce tenant/resource authorization itself.
+   * @returns The callback result without cloning.
+   * @throws Rejects inactive plugin, lifecycle/store validation failure or callback rejection.
+   * 
+   * @remarks
+   * The admission check does not hold a lock or pin activation throughout callback execution. Host quiesce/drain and live authorization remain required.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle } from '@alneas/eaos-server/lifecycle-engine';
+   * export function runAdmitted<T>(lifecycle: PluginLifecycle, backendId: string, tenantId: string, pluginId: string, work: () => Promise<T>) { return lifecycle.run(backendId, tenantId, pluginId, work); }
+   * ```
+   */
+  async run(backendId, tenantId, pluginId, callback) {
+    if (!await this.isEnabled(backendId, tenantId, pluginId)) throw new Error("Plugin is inactive");
+    return callback();
+  }
+  /**
+   * Checks plan freshness and invokes host infrastructure previews without applying ledger changes.
+   * @param plan - Unmodified lifecycle plan to preview.
+   * @returns Preview results in infrastructure-step order, or an empty array when no infrastructure is needed.
+   * @throws Rejects stale/modified plan, missing infrastructure adapter or propagated plan/preview errors.
+   * 
+   * @remarks
+   * Infrastructure previews run concurrently through Promise.all. Host preview adapters own any external read/preview effects; this method executes no migrations.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle, type LifecyclePlan } from '@alneas/eaos-server/lifecycle-engine';
+   * export function preview(lifecycle: PluginLifecycle, plan: LifecyclePlan) { return lifecycle.preview(plan); }
+   * ```
+   */
+  async preview(plan) {
+    const fresh = await this.plan(plan.request);
+    if (canonical(fresh) !== canonical(plan)) throw new Error("Stale or modified lifecycle plan");
+    if (plan.infrastructure.length && !this.project.infrastructure) throw new Error("Infrastructure executor is required");
+    return Promise.all(plan.infrastructure.map((s) => this.project.infrastructure.preview(s)));
+  }
+  /**
+   * Revalidates and executes a reviewed lifecycle plan while holding the host's exclusive ledger lock.
+   * @param plan - Unmodified plan bound to the current ledger revision and registered configuration.
+   * @returns Resolves without a value after ledger updates and requested side effects complete.
+   * @throws Rejects stale/modified plan, missing executors/quiesce, reconciliation conflicts or host store, migration, infrastructure or drain failures.
+   * 
+   * @remarks
+   * Before upgrade side effects, affected activations are disabled durably and all-instance quiesce is required. Infrastructure/migration running/applied/failed receipts are persisted separately. Errors can follow partial external success; no automatic rollback/retry occurs. Uninstall retains business data and migration history.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginLifecycle, type LifecyclePlan } from '@alneas/eaos-server/lifecycle-engine';
+   * export function applyReviewed(lifecycle: PluginLifecycle, plan: LifecyclePlan) { return lifecycle.apply(plan); }
+   * ```
+   */
+  async apply(plan) {
+    plan = JSON.parse(canonical(plan));
+    await this.project.store.withLock(async (writer) => {
+      const state = await writer.read(), fresh = this.makePlan(plan.request, state);
+      if (canonical(fresh) !== canonical(plan)) throw new Error("Stale or modified lifecycle plan");
+      if (plan.infrastructure.length && !this.project.infrastructure) throw new Error("Infrastructure executor is required");
+      if (["install", "update"].includes(plan.request.operation) && plan.deactivate.length && !this.project.quiesce) throw new Error("A quiesce executor is required for active deployments");
+      const save = async () => {
+        state.revision++;
+        await writer.write(state);
+      };
+      const { request, backend } = plan;
+      state.backends[backend.id] = backend;
+      for (const k of plan.deactivate) if (state.activations[k]) state.activations[k].enabled = false;
+      if (request.operation === "install" || request.operation === "update") {
+        for (const p of plan.plugins) state.installations[key(backend.id, p.id)] = { release: p, digest: lifecycleDigest(p), status: "installing" };
+        state.dataContracts ??= {};
+        for (const contract of plan.dataCatalog?.contracts ?? []) state.dataContracts[key(backend.databaseId, contract.id)] = { contract, digest: lifecycleDigest(contract), status: "installing" };
+        await save();
+        try {
+          if (plan.deactivate.length) await this.project.quiesce(plan.deactivate.map((k) => state.activations[k]));
+          for (const step of plan.infrastructure) {
+            state.infrastructure[step.key] = { digest: step.digest, status: "running" };
+            await save();
+            try {
+              await this.project.infrastructure.apply(step);
+            } catch (error) {
+              state.infrastructure[step.key].status = "failed";
+              await save();
+              throw error;
+            }
+            state.infrastructure[step.key].status = "applied";
+            await save();
+          }
+          for (const step of plan.migrations) {
+            state.migrations[step.key] = { ...step.record };
+            await save();
+            try {
+              await this.project.migrate(step, backend);
+            } catch (error) {
+              state.migrations[step.key].status = "failed";
+              await save();
+              throw error;
+            }
+            state.migrations[step.key].status = "applied";
+            await save();
+          }
+          for (const contract of plan.dataCatalog?.contracts ?? []) state.dataContracts[key(backend.databaseId, contract.id)].status = "installed";
+          for (const p of plan.plugins) state.installations[key(backend.id, p.id)].status = "installed";
+        } catch (error) {
+          for (const contract of plan.dataCatalog?.contracts ?? []) state.dataContracts[key(backend.databaseId, contract.id)].status = "failed";
+          for (const p of plan.plugins) state.installations[key(backend.id, p.id)].status = "failed";
+          await save();
+          throw error;
+        }
+      } else if (request.operation === "enable") {
+        for (const p of plan.plugins) state.activations[key(backend.id, request.tenantId, p.id)] = { backendId: backend.id, tenantId: request.tenantId, pluginId: p.id, digest: lifecycleDigest(p), enabled: true };
+      } else if (request.operation === "uninstall") delete state.installations[key(backend.id, request.pluginId)];
+      await save();
+    });
+  }
+};
+
+// src/lifecycle-engine/baseline.ts
+function createDataContractBaseline(source, version2, sql) {
+  if (!valid2(version2) || !lt2(source.version, version2) || !source.migrations.length || source.migrations.some((m) => m.scope !== "database")) throw Error("Baseline requires a newer contract version and database-scoped migrations");
+  const dialects = [...new Set(source.migrations.flatMap((m) => Object.keys(m.sql)))].sort();
+  if (JSON.stringify(dialects) !== JSON.stringify(Object.keys(sql).sort())) throw Error("Baseline must preserve every declared dialect");
+  const target = { ...structuredClone(source), version: version2, migrations: [{ id: `001_baseline_v${version2.replaceAll(".", "_").replaceAll("-", "_")}`, scope: "database", sql: structuredClone(sql) }] };
+  resolveDataContracts2([{ ...source, dependencies: void 0 }], { [source.id]: source.version });
+  resolveDataContracts2([{ ...target, dependencies: void 0 }], { [target.id]: version2 });
+  const body = { format: 1, source: structuredClone(source), target, replaces: source.migrations.map((m, position) => ({ id: m.id, position, checksum: lifecycleDigest(m) })) };
+  return { ...body, hash: lifecycleDigest(body) };
+}
+async function rebaseDataContractBaseline(store, databaseId, baseline, options) {
+  const { hash, ...body } = baseline;
+  if (hash !== lifecycleDigest(body) || hash !== createDataContractBaseline(baseline.source, baseline.target.version, baseline.target.migrations[0]?.sql ?? {}).hash) throw Error("Baseline integrity differs");
+  return store.withLock(async (writer) => {
+    const state = await writer.read();
+    if (state.revision !== options.expectedRevision) throw Error("Baseline plan is stale");
+    const key2 = JSON.stringify([databaseId, baseline.source.id]), installed = state.dataContracts?.[key2];
+    if (!installed || installed.status !== "installed" || installed.digest !== lifecycleDigest(baseline.source)) throw Error("Baseline source contract is not completely installed");
+    const identity = baseline.source.migrationIdentity ?? `data-${baseline.source.id}`;
+    const history = Object.entries(state.migrations).filter(([, r]) => r.databaseId === databaseId && r.pluginId === identity);
+    if (history.length !== baseline.replaces.length || baseline.replaces.some((replaced) => !history.some(([, r]) => r.migrationId === replaced.id && r.position === replaced.position && r.checksum === replaced.checksum && r.tenantId === null && r.status === "applied"))) throw Error("Baseline history is partial, changed or dirty");
+    for (const [key3, installed2] of Object.entries(state.installations)) {
+      const range = installed2.release.schemaDependencies?.[baseline.source.id];
+      if (state.backends[JSON.parse(key3)[0]]?.databaseId === databaseId && range && !satisfies2(baseline.target.version, range)) throw Error("Baseline violates an installed plugin contract range");
+    }
+    const live = Object.values(state.activations).filter((a) => a.enabled && state.backends[a.backendId]?.databaseId === databaseId && state.installations[JSON.stringify([a.backendId, a.pluginId])]?.release.schemaDependencies?.[baseline.source.id]);
+    if (live.length && !options.quiesce) throw Error("Baseline requires all-instance drain");
+    if (live.length) await options.quiesce({ databaseId, pluginIds: [...new Set(live.map((a) => a.pluginId))] });
+    for (const a of live) a.enabled = false;
+    state.baselineHistory ??= {};
+    const archiveKey = JSON.stringify([databaseId, identity, hash]);
+    if (state.baselineHistory[archiveKey]) throw Error("Baseline history already exists");
+    state.baselineHistory[archiveKey] = { hash, source: baseline.source, migrations: Object.fromEntries(history) };
+    for (const [key3] of history) delete state.migrations[key3];
+    const m = baseline.target.migrations[0];
+    state.migrations[JSON.stringify([databaseId, identity, m.id, "*"])] = { databaseId, pluginId: identity, migrationId: m.id, position: 0, tenantId: null, checksum: lifecycleDigest(m), status: "applied" };
+    state.dataContracts[key2] = { contract: structuredClone(baseline.target), digest: lifecycleDigest(baseline.target), status: "installed" };
+    state.revision++;
+    await writer.write(state);
+    return { baselineHash: hash, revision: state.revision, rebased: history.length, ddlExecuted: false };
+  });
+}
+
+export {
+  createDataContractBaseline,
+  rebaseDataContractBaseline,
+  FRAMEWORK_VERSION,
+  emptyLifecyclePlatformState,
+  emptyLifecycleState,
+  normalizeLifecycleState,
+  canonical,
+  lifecycleDigest,
+  PluginLifecycle,
+  dataContractTables2 as dataContractTables,
+  resolveDataContracts2 as resolveDataContracts,
+  assertDataContractBinding,
+  collectSchemaMigrations,
+  createJsonDocumentAssertion,
+  assertJsonDocumentContracts,
+  planBackendMigration,
+  assertBackendMigrationVerification,
+  assertBackendMigrationCutover
+};
+//# sourceMappingURL=chunk-SDJNYPYK.js.map