@revoengine/cli 1.0.10 → 1.0.11

package/dist/src/resource-syncs/database-schema-sync.js

@@ -0,0 +1,2289 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ApiError } from "../client.js";
+import { hashStable, readComponentLock, writeComponentLock, } from "../component-lock.js";
+import { excludeDatabaseBackupArtifacts, isDatabaseBackupArtifact } from "../database-schema-artifacts.js";
+import { readConfiguredResourceMetadataStableKey, sanitizeUserMetadata } from "../resource-metadata.js";
+import { readJsonFile, sanitizeSegment } from "../utils.js";
+import { findManifestFiles, isRecord, localTargetPath, removeRelocatedManifest, requireProjectLayout, stableKeySuffix, toPortableRelativePath, unwrapData, writePulledManifest, } from "./util.js";
+export const DATABASE_SCHEMAS_DIRECTORY = 'DatabaseSchemas';
+export const DATABASE_SCHEMA_MANIFEST_FILE = 'database-schema.json';
+const INSTANCE_FIELDS = new Set([
+    'databaseId', 'databaseDefinitionId', 'id', 'version', 'revision', 'details', 'records',
+    'createdAt', 'createdBy', 'lastUpdateAt', 'lastUpdateBy', 'updatedAt', 'updatedBy',
+    'deletedAt', 'deletedBy', 'users', 'groups', 'restricted', 'audit', 'tags',
+]);
+function databaseIdOf(record) {
+    return String(record.databaseId || record.id || '');
+}
+function label(record) {
+    const category = typeof record.category === 'string' && record.category.trim()
+        ? record.category.trim()
+        : 'Uncategorized';
+    return `${category}/${String(record.name || databaseIdOf(record) || 'unknown')}`;
+}
+function canonicalValue(value, omitInstanceFields = false) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => canonicalValue(entry, omitInstanceFields));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.keys(value)
+        .filter((key) => !omitInstanceFields || !INSTANCE_FIELDS.has(key))
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, canonicalValue(value[key], omitInstanceFields)]));
+}
+function portableDefinition(value) {
+    const definition = canonicalValue(value, true);
+    if (!Object.hasOwn(definition, 'metadata')) {
+        return definition;
+    }
+    const metadata = sanitizeUserMetadata(definition.metadata);
+    if (Object.keys(metadata).length === 0) {
+        const { metadata: _metadata, ...withoutMetadata } = definition;
+        return withoutMetadata;
+    }
+    return {
+        ...definition,
+        metadata: canonicalValue(metadata),
+    };
+}
+function portableDefinitions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((definition) => portableDefinition(definition));
+}
+function configuredStableKey(record, stableKeyName) {
+    return readConfiguredResourceMetadataStableKey(record, stableKeyName);
+}
+function rawStableKey(record, stableKeyName) {
+    for (const metadata of [record.metadata, record.metaData, record.resourceMetadata]) {
+        if (isRecord(metadata) && Object.hasOwn(metadata, stableKeyName)) {
+            return { present: true, value: metadata[stableKeyName] };
+        }
+    }
+    return { present: false, value: undefined };
+}
+function parentCandidates(record) {
+    const candidates = [];
+    if (typeof record.parentId === 'string' && record.parentId) {
+        candidates.push({ kind: 'id', value: record.parentId });
+    }
+    if (typeof record.parent === 'string' && record.parent) {
+        candidates.push({ kind: 'name', value: record.parent });
+    }
+    else if (isRecord(record.parent)) {
+        const id = record.parent.databaseId || record.parent.id;
+        if (typeof id === 'string' && id) {
+            candidates.push({ kind: 'id', value: id });
+        }
+        if (typeof record.parent.name === 'string' && record.parent.name) {
+            candidates.push({ kind: 'name', value: record.parent.name });
+        }
+    }
+    return candidates;
+}
+function hasForeignReferences(definition) {
+    return definition.some((column) => Array.isArray(column.foreignReferences) && column.foreignReferences.length > 0);
+}
+function manifestFromEntry(entry, stableKeyName) {
+    const record = entry.record;
+    const metadata = canonicalValue({
+        ...sanitizeUserMetadata(record.resourceMetadata),
+        ...sanitizeUserMetadata(record.metaData),
+        ...sanitizeUserMetadata(record.metadata),
+        [stableKeyName]: entry.stableKey,
+    });
+    const definition = Array.isArray(record.definition)
+        ? portableDefinitions(record.definition)
+        : [];
+    const partition = isRecord(record.partition)
+        ? canonicalValue(record.partition, true)
+        : undefined;
+    const common = {
+        stableKey: entry.stableKey,
+        name: String(record.name || ''),
+        ...(record.category === undefined ? {} : { category: record.category }),
+        ...(typeof record.desc === 'string' && record.desc
+            ? { description: record.desc }
+            : typeof record.description === 'string' && record.description
+                ? { description: record.description }
+                : {}),
+        metadata,
+    };
+    if (entry.parentStableKey) {
+        return {
+            kind: 'database-partition',
+            ...common,
+            parentStableKey: entry.parentStableKey,
+            ...(partition ? { partition } : {}),
+            ...(hasForeignReferences(definition) ? { migration: { foreignReferences: 'manual' } } : {}),
+        };
+    }
+    return {
+        kind: 'database-schema',
+        ...common,
+        ...(typeof record.type === 'string' ? { type: record.type } : {}),
+        definition,
+        ...(partition ? { partition } : {}),
+        ...(hasForeignReferences(definition) ? { migration: { foreignReferences: 'manual' } } : {}),
+    };
+}
+function portableDatabaseSchemaManifest(manifest) {
+    const common = {
+        stableKey: manifest.stableKey,
+        name: manifest.name,
+        ...(manifest.category === undefined ? {} : { category: manifest.category }),
+        ...(typeof manifest.description === 'string' && manifest.description ? { description: manifest.description } : {}),
+        metadata: canonicalValue(sanitizeUserMetadata(manifest.metadata)),
+        ...(manifest.migration === undefined
+            ? {}
+            : { migration: canonicalValue(manifest.migration) }),
+    };
+    if (manifest.kind === 'database-partition') {
+        return {
+            kind: manifest.kind,
+            ...common,
+            ...(manifest.parentStableKey === undefined ? {} : { parentStableKey: manifest.parentStableKey }),
+            ...(manifest.partition === undefined
+                ? {}
+                : { partition: canonicalValue(manifest.partition, true) }),
+        };
+    }
+    return {
+        kind: manifest.kind,
+        ...common,
+        ...(manifest.type === undefined ? {} : { type: manifest.type }),
+        ...(manifest.definition === undefined
+            ? {}
+            : { definition: portableDefinitions(manifest.definition) }),
+        ...(manifest.partition === undefined
+            ? {}
+            : { partition: canonicalValue(manifest.partition, true) }),
+    };
+}
+export function hashPortableDatabaseSchema(manifest) {
+    return hashStable(portableDatabaseSchemaManifest(manifest));
+}
+function rootManifestPath(workspaceRoot, manifest) {
+    const category = typeof manifest.category === 'string' && manifest.category.trim()
+        ? sanitizeSegment(manifest.category)
+        : 'Uncategorized';
+    return path.join(workspaceRoot, DATABASE_SCHEMAS_DIRECTORY, category, `${sanitizeSegment(manifest.name)}-${stableKeySuffix(manifest.stableKey)}`, DATABASE_SCHEMA_MANIFEST_FILE);
+}
+function pathIdentity(filePath) {
+    return path.resolve(filePath)
+        .normalize('NFC')
+        .split(path.sep)
+        .map((segment) => segment.replace(/[. ]+$/g, '').toLowerCase())
+        .join(path.sep);
+}
+function loadWorkspaceManifests(workspaceRoot) {
+    return findManifestFiles(path.join(workspaceRoot, DATABASE_SCHEMAS_DIRECTORY), DATABASE_SCHEMA_MANIFEST_FILE)
+        .map((manifestPath) => ({
+        manifestPath,
+        manifest: readJsonFile(manifestPath),
+    }))
+        .filter(({ manifest }) => !isDatabaseBackupArtifact(manifest));
+}
+function emptyPlanCounts() {
+    return {
+        clean: 0,
+        create: 0,
+        'safe-update': 0,
+        'remote-changed': 0,
+        conflict: 0,
+        'missing-lock': 0,
+        'orphan-root': 0,
+        'orphan-partition': 0,
+        'delete-partition': 0,
+        'previously-deleted-partition': 0,
+        'replacement-requires-two-phases': 0,
+        unmanaged: 0,
+        collision: 0,
+        reconciled: 0,
+        'manual-schema-migration-required': 0,
+        'access-policy-required': 0,
+    };
+}
+function physicalNameHint(value) {
+    return String(value.name || '').normalize('NFC');
+}
+function validatePlanManifest(manifest, stableKeyName) {
+    if (!isRecord(manifest)) {
+        return ['manifest must be an object'];
+    }
+    const errors = [];
+    if (manifest.kind !== 'database-schema' && manifest.kind !== 'database-partition') {
+        errors.push('kind must be database-schema or database-partition');
+    }
+    if (typeof manifest.stableKey !== 'string' || !manifest.stableKey.trim()) {
+        errors.push('stableKey must be a non-empty string');
+    }
+    if (typeof manifest.name !== 'string' || !manifest.name.trim()) {
+        errors.push('name must be a non-empty string');
+    }
+    if (!isRecord(manifest.metadata)) {
+        errors.push('metadata must be an object');
+    }
+    else if (typeof manifest.stableKey === 'string' && manifest.metadata[stableKeyName] !== manifest.stableKey) {
+        errors.push(`metadata.${stableKeyName} must match stableKey`);
+    }
+    if (manifest.kind === 'database-schema' && !Array.isArray(manifest.definition)) {
+        errors.push('database-schema definition must be an array');
+    }
+    else if (manifest.kind === 'database-schema' && Array.isArray(manifest.definition)) {
+        const names = manifest.definition.map((column) => isRecord(column) && typeof column.name === 'string' ? column.name : '');
+        if (names.some((name) => !name)) {
+            errors.push('every database column must have a non-empty exact name');
+        }
+        if (new Set(names).size !== names.length) {
+            errors.push('database column names must be unique');
+        }
+        if (manifest.parentStableKey !== undefined) {
+            errors.push('database-schema must not declare parentStableKey');
+        }
+    }
+    if (manifest.kind === 'database-partition') {
+        if (typeof manifest.parentStableKey !== 'string' || !manifest.parentStableKey.trim()) {
+            errors.push('database-partition parentStableKey must be a non-empty string');
+        }
+        if (!isRecord(manifest.partition)) {
+            errors.push('database-partition partition must be an object');
+        }
+        if (manifest.definition !== undefined) {
+            errors.push('database-partition must not duplicate the inherited definition');
+        }
+        if (manifest.type !== undefined) {
+            errors.push('database-partition must not declare an inherited type');
+        }
+    }
+    return errors;
+}
+function valuesEqual(left, right) {
+    return hashStable({ value: left }) === hashStable({ value: right });
+}
+function manualHint(field) {
+    if (field === 'name') {
+        return 'Create a replacement table with a new Stable Key, copy and verify the data, switch dependants, then retire the old table in a reviewed migration.';
+    }
+    if (field === 'parentStableKey' || field === 'partition') {
+        return 'Create a replacement partition with a new Stable Key, migrate and verify rows, then detach the old partition in a later forced prune phase.';
+    }
+    return 'Run an explicit reviewed DDL migration, estimate lock and table-rewrite impact, back up affected data, verify row counts and indexes, then reconcile the manifest.';
+}
+function safeFieldHint(field) {
+    if (field === 'definition') {
+        return 'Apply only the reviewed additive or presentation-only definition change; monitor the short schema lock and verify the resulting definition.';
+    }
+    return 'This portable metadata change does not rewrite table data; verify the live value and advance the selected environment lock after a successful push.';
+}
+function sizeRiskHint(size) {
+    if (!size) {
+        return undefined;
+    }
+    return `Observed target size: ${size.total} bytes total (${size.table} table, ${size.indexes} indexes, ${size.audit} audit). Use it to choose the maintenance window and timeout for scans, rewrites, and index work.`;
+}
+function columnName(column) {
+    return typeof column.name === 'string' ? column.name : '';
+}
+function rawColumnStableKey(column, stableKeyName) {
+    const metadata = column.metadata;
+    if (!isRecord(metadata) || !Object.hasOwn(metadata, stableKeyName)) {
+        return { present: false, value: undefined };
+    }
+    return { present: true, value: metadata[stableKeyName] };
+}
+function columnStableKey(column, stableKeyName) {
+    const raw = rawColumnStableKey(column, stableKeyName);
+    return typeof raw.value === 'string' && raw.value.trim() ? raw.value : null;
+}
+function columnStableKeyValidationChanges(columns, stableKeyName, side) {
+    const changes = [];
+    const byKey = new Map();
+    for (const column of columns) {
+        const name = columnName(column) || 'unknown';
+        const raw = rawColumnStableKey(column, stableKeyName);
+        if (raw.present && !columnStableKey(column, stableKeyName)) {
+            changes.push({
+                kind: 'column-changed',
+                field: `definition.${name}.metadata.${stableKeyName}`,
+                column: name,
+                risk: 'manual',
+                after: raw.value,
+                hint: `The ${side} column Stable Key must be a non-empty string. Repair it manually before any schema synchronization.`,
+            });
+            continue;
+        }
+        const key = columnStableKey(column, stableKeyName);
+        if (key) {
+            byKey.set(key, [...(byKey.get(key) || []), column]);
+        }
+    }
+    for (const [key, duplicates] of byKey) {
+        if (duplicates.length < 2) {
+            continue;
+        }
+        for (const column of duplicates) {
+            const name = columnName(column) || 'unknown';
+            changes.push({
+                kind: 'column-changed',
+                field: `definition.${name}.metadata.${stableKeyName}`,
+                column: name,
+                risk: 'manual',
+                after: key,
+                hint: `Duplicate ${side} column Stable Key "${key}". Assign unique column keys manually before any schema synchronization.`,
+            });
+        }
+    }
+    return changes;
+}
+function columnBoolean(column, names) {
+    return names.some((name) => column[name] === true);
+}
+function isSafeColumnAddition(column) {
+    const nullable = column.nullable === true || column.isNullable === true;
+    const hasDefault = column.default !== undefined && column.default !== null;
+    const constrained = columnBoolean(column, [
+        'primary', 'isPrimary', 'primaryKey', 'isPrimaryKey',
+        'unique', 'isUnique', 'index', 'indexed', 'isIndex', 'isIndexed',
+    ]);
+    const references = Array.isArray(column.foreignReferences) && column.foreignReferences.length > 0;
+    return nullable && !hasDefault && !constrained && !references;
+}
+function diffDefinitions(desired, current, stableKeyName) {
+    const changes = [];
+    changes.push(...columnStableKeyValidationChanges(desired, stableKeyName, 'desired'));
+    changes.push(...columnStableKeyValidationChanges(current, stableKeyName, 'target'));
+    const currentByName = new Map();
+    for (const column of current) {
+        const name = columnName(column);
+        currentByName.set(name, [...(currentByName.get(name) || []), column]);
+    }
+    const currentByStableKey = new Map();
+    const desiredByStableKey = new Map();
+    for (const column of current) {
+        const stableKey = columnStableKey(column, stableKeyName);
+        if (stableKey) {
+            currentByStableKey.set(stableKey, [...(currentByStableKey.get(stableKey) || []), column]);
+        }
+    }
+    for (const column of desired) {
+        const stableKey = columnStableKey(column, stableKeyName);
+        if (stableKey) {
+            desiredByStableKey.set(stableKey, [...(desiredByStableKey.get(stableKey) || []), column]);
+        }
+    }
+    const matchedCurrentByDesired = new Map();
+    const matchedDesired = new Set();
+    const matchedCurrent = new Set();
+    for (const desiredColumn of desired) {
+        const stableKey = columnStableKey(desiredColumn, stableKeyName);
+        const stableKeyMatches = stableKey ? currentByStableKey.get(stableKey) || [] : [];
+        const stableKeyIsUnique = stableKeyMatches.length === 1 && (desiredByStableKey.get(stableKey) || []).length === 1;
+        const namedMatches = currentByName.get(columnName(desiredColumn)) || [];
+        const namedMatch = namedMatches.length === 1 ? namedMatches[0] : undefined;
+        const canUseLegacyNameMatch = Boolean(namedMatch) && (!stableKey || !columnStableKey(namedMatch, stableKeyName));
+        const currentColumn = stableKeyIsUnique
+            ? stableKeyMatches[0]
+            : canUseLegacyNameMatch
+                ? namedMatch
+                : undefined;
+        if (!currentColumn || matchedCurrent.has(currentColumn)) {
+            continue;
+        }
+        matchedCurrentByDesired.set(desiredColumn, currentColumn);
+        matchedDesired.add(desiredColumn);
+        matchedCurrent.add(currentColumn);
+    }
+    const reportMissingStableKey = (desiredColumn, currentColumn) => {
+        const desiredStableKey = desiredColumn ? columnStableKey(desiredColumn, stableKeyName) : null;
+        const currentStableKey = currentColumn ? columnStableKey(currentColumn, stableKeyName) : null;
+        if (desiredStableKey && currentStableKey) {
+            return;
+        }
+        const name = columnName(desiredColumn || currentColumn || {});
+        if (!name) {
+            return;
+        }
+        const missingSides = [
+            ...(desiredStableKey ? [] : ['desired']),
+            ...(currentStableKey ? [] : ['target']),
+        ];
+        changes.push({
+            kind: 'column-stable-key-missing',
+            field: `definition.${name}.metadata.${stableKeyName}`,
+            column: name,
+            risk: 'operational',
+            before: currentStableKey || undefined,
+            after: desiredStableKey || undefined,
+            hint: `Column "${name}" is missing a Stable Key on the ${missingSides.join(' and ')} side. It remains non-blocking work in progress and uses exact-name matching until the source bootstrap assigns a unique key.`,
+        });
+    };
+    for (const [desiredColumn, currentColumn] of matchedCurrentByDesired) {
+        reportMissingStableKey(desiredColumn, currentColumn);
+    }
+    for (const column of desired) {
+        if (!matchedDesired.has(column)) {
+            reportMissingStableKey(column, undefined);
+        }
+    }
+    for (const column of current) {
+        if (!matchedCurrent.has(column)) {
+            reportMissingStableKey(undefined, column);
+        }
+    }
+    for (const column of desired) {
+        const name = columnName(column);
+        if (!name || matchedDesired.has(column)) {
+            continue;
+        }
+        const safe = isSafeColumnAddition(column);
+        const stableKey = columnStableKey(column, stableKeyName);
+        const controlledKeyedAddition = Boolean(stableKey
+            && (desiredByStableKey.get(stableKey) || []).length === 1
+            && (currentByStableKey.get(stableKey) || []).length === 0);
+        changes.push({
+            kind: 'column-added',
+            field: `definition.${name}`,
+            column: name,
+            risk: safe ? 'safe' : controlledKeyedAddition ? 'operational' : 'manual',
+            after: column,
+            hint: safe
+                ? 'Add this nullable column without a default, primary key, unique constraint, or index; this avoids a table rewrite, but still monitor the schema lock.'
+                : controlledKeyedAddition
+                    ? 'Add this new column through its unique Stable Key. Review target size and existing rows, use an appropriate maintenance window for default backfill, validation, index work, or table rewrites, and verify the resulting definition.'
+                    : 'Use an explicit DDL migration and staged backfill; adding a required/defaulted/indexed/unique column can scan or rewrite a large table and hold locks.',
+        });
+    }
+    for (const column of current) {
+        const name = columnName(column);
+        if (!name || matchedCurrent.has(column)) {
+            continue;
+        }
+        changes.push({
+            kind: 'column-removed',
+            field: `definition.${name}`,
+            column: name,
+            risk: 'manual',
+            before: column,
+            hint: 'Back up and verify the column data, update all dependants, and remove the column only through an explicit reviewed DDL migration; a drop is data loss.',
+        });
+    }
+    for (const [desiredColumn, currentColumn] of matchedCurrentByDesired) {
+        const name = columnName(desiredColumn);
+        const currentName = columnName(currentColumn);
+        if (!name || !currentName) {
+            continue;
+        }
+        if (name !== currentName) {
+            changes.push({
+                kind: 'column-renamed',
+                field: `definition.${currentName}.name`,
+                column: currentName,
+                risk: 'operational',
+                before: currentName,
+                after: name,
+                hint: `Rename column "${currentName}" to "${name}" through its shared column Stable Key. This keeps the target column identity, but requires a reviewed maintenance window and no active Database View dependency.`,
+            });
+        }
+        const desiredStableKey = columnStableKey(desiredColumn, stableKeyName);
+        const currentStableKey = columnStableKey(currentColumn, stableKeyName);
+        const uniquelyMatchedByStableKey = Boolean(desiredStableKey
+            && desiredStableKey === currentStableKey
+            && (desiredByStableKey.get(desiredStableKey) || []).length === 1
+            && (currentByStableKey.get(desiredStableKey) || []).length === 1);
+        const keys = [...new Set([...Object.keys(desiredColumn), ...Object.keys(currentColumn)])]
+            .filter((key) => key !== 'name')
+            .sort((left, right) => left.localeCompare(right));
+        for (const key of keys) {
+            if (valuesEqual(desiredColumn[key], currentColumn[key])) {
+                continue;
+            }
+            const presentationOnly = key === 'desc' || key === 'metadata';
+            const controlledDefinitionChange = key !== 'foreignReferences' && uniquelyMatchedByStableKey;
+            changes.push({
+                kind: 'column-changed',
+                field: `definition.${name}.${key}`,
+                column: name,
+                risk: presentationOnly ? 'safe' : controlledDefinitionChange ? 'operational' : 'manual',
+                before: currentColumn[key],
+                after: desiredColumn[key],
+                hint: presentationOnly
+                    ? 'Column metadata is portable presentation metadata; update it without retyping, rebuilding, or changing constraints.'
+                    : controlledDefinitionChange
+                        ? `Update ${key} on this existing column through its shared Stable Key. Review data compatibility and target size, use an appropriate maintenance window for locks, scans, rewrites, validation, or index work, and verify the resulting definition.`
+                        : `Review ${key} as an explicit DDL migration: estimate locks, scans, rewrites, index work, validation cost, and data-conversion risk before reconciling the manifest.`,
+            });
+        }
+    }
+    const desiredSharedOrder = desired
+        .filter((column) => matchedDesired.has(column))
+        .map(columnName);
+    const currentSharedOrder = current
+        .filter((column) => matchedCurrent.has(column))
+        .map(columnName);
+    if (!valuesEqual(desiredSharedOrder, currentSharedOrder)) {
+        changes.push({
+            kind: 'column-order',
+            field: 'definition.order',
+            risk: 'safe',
+            before: currentSharedOrder,
+            after: desiredSharedOrder,
+            hint: 'Column order is presentation-only in the portable contract; do not rebuild or rewrite the physical table for this change.',
+        });
+    }
+    return changes;
+}
+function diffDatabaseSchemas(desired, current, stableKeyName) {
+    const changes = [];
+    const immutableFields = ['kind', 'name', 'parentStableKey', 'partition'];
+    for (const field of immutableFields) {
+        if (valuesEqual(desired[field], current[field])) {
+            continue;
+        }
+        changes.push({
+            kind: 'immutable-field',
+            field,
+            risk: 'manual',
+            before: current[field],
+            after: desired[field],
+            hint: manualHint(field),
+        });
+    }
+    if (!valuesEqual(desired.type, current.type)) {
+        changes.push({
+            kind: 'immutable-field',
+            field: 'type',
+            risk: 'manual',
+            before: current.type,
+            after: desired.type,
+            hint: 'Changing the physical table kind can rebuild storage and dependencies; use a replacement table with a new Stable Key and an explicit data migration.',
+        });
+    }
+    for (const field of ['category', 'description', 'metadata']) {
+        if (valuesEqual(desired[field], current[field])) {
+            continue;
+        }
+        const cannotClearCategory = field === 'category' && (desired.category === undefined || desired.category === null);
+        changes.push({
+            kind: 'field-changed',
+            field,
+            risk: cannotClearCategory ? 'manual' : 'safe',
+            before: current[field],
+            after: desired[field],
+            hint: cannotClearCategory
+                ? 'The current Database API accepts a category value but cannot clear one. Clear it through the target UI or a reviewed backend migration, then reconcile the manifest.'
+                : safeFieldHint(field),
+        });
+    }
+    if (desired.kind === 'database-schema' && current.kind === 'database-schema') {
+        changes.push(...diffDefinitions(desired.definition || [], current.definition || [], stableKeyName));
+    }
+    const hasReferences = desired.migration?.foreignReferences === 'manual'
+        || current.migration?.foreignReferences === 'manual'
+        || hasForeignReferences(desired.definition || [])
+        || hasForeignReferences(current.definition || []);
+    const migrationMarkerChanged = !valuesEqual(desired.migration, current.migration);
+    if (hasReferences && (changes.length > 0 || migrationMarkerChanged)) {
+        changes.push({
+            kind: 'foreign-reference',
+            field: 'definition.foreignReferences',
+            risk: 'manual',
+            hint: 'Foreign-reference declarations are not enforced as SQL constraints by the API; deploy and verify the relationship manually before reconciling this table.',
+        });
+    }
+    return changes;
+}
+function partitionBoundsOverlap(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    const leftFrom = typeof left.from === 'string' ? left.from : undefined;
+    const leftTo = typeof left.to === 'string' ? left.to : undefined;
+    const rightFrom = typeof right.from === 'string' ? right.from : undefined;
+    const rightTo = typeof right.to === 'string' ? right.to : undefined;
+    if (leftFrom && leftTo && rightFrom && rightTo) {
+        return leftFrom < rightTo && rightFrom < leftTo;
+    }
+    const leftValues = Array.isArray(left.values) ? left.values : undefined;
+    const rightValues = Array.isArray(right.values) ? right.values : undefined;
+    if (leftValues && rightValues) {
+        return leftValues.some((value) => rightValues.some((candidate) => valuesEqual(value, candidate)));
+    }
+    return String(left.type || '').toUpperCase() === 'HASH' && String(right.type || '').toUpperCase() === 'HASH';
+}
+function targetPlanCatalog(records, stableKeyName) {
+    const migratableRecords = excludeDatabaseBackupArtifacts(records);
+    const recordsById = new Map(migratableRecords.map((record) => [databaseIdOf(record), record]));
+    const recordsByName = new Map();
+    for (const record of migratableRecords) {
+        const name = String(record.name || '');
+        recordsByName.set(name, [...(recordsByName.get(name) || []), record]);
+    }
+    const resolveParent = (record) => {
+        const references = parentCandidates(record);
+        if (references.length === 0) {
+            return { parentId: null, parent: undefined };
+        }
+        const parents = new Set();
+        for (const reference of references) {
+            if (reference.kind === 'id') {
+                const parent = recordsById.get(reference.value);
+                if (parent) {
+                    parents.add(parent);
+                }
+            }
+            else {
+                for (const parent of recordsByName.get(reference.value) || []) {
+                    parents.add(parent);
+                }
+            }
+        }
+        if (parents.size !== 1) {
+            return { parentId: '', parent: undefined };
+        }
+        const parent = [...parents][0];
+        return { parentId: databaseIdOf(parent), parent };
+    };
+    const managed = [];
+    const unmanaged = [];
+    for (const record of migratableRecords) {
+        const stableKey = configuredStableKey(record, stableKeyName);
+        if (!stableKey) {
+            unmanaged.push({ record, reason: `missing ${stableKeyName}; unmanaged WIP` });
+            continue;
+        }
+        const resolved = resolveParent(record);
+        let parentStableKey;
+        if (resolved.parentId !== null) {
+            parentStableKey = resolved.parent
+                ? configuredStableKey(resolved.parent, stableKeyName) || undefined
+                : undefined;
+            if (!resolved.parentId || !parentStableKey) {
+                unmanaged.push({ record, reason: `parent is missing or unmanaged; missing ${stableKeyName}` });
+                continue;
+            }
+        }
+        const entry = {
+            record,
+            id: databaseIdOf(record),
+            stableKey,
+            parentId: resolved.parentId,
+            ...(parentStableKey ? { parentStableKey } : {}),
+        };
+        const manifest = manifestFromEntry(entry, stableKeyName);
+        managed.push({ record, manifest, hash: hashPortableDatabaseSchema(manifest), databaseId: entry.id });
+    }
+    return { managed, unmanaged };
+}
+export async function buildDatabaseSchemasPlan(input) {
+    const { projectRoot, workspaceRoot } = requireProjectLayout(input.cwd, 'Database Schema');
+    const localEntries = loadWorkspaceManifests(workspaceRoot).filter((entry) => (input.skipPartitions !== true
+        || !isRecord(entry.manifest)
+        || entry.manifest.kind !== 'database-partition'));
+    const { databases } = await input.client.listAllDatabaseSchemas({
+        projection: 'pull',
+        skipPartitions: input.skipPartitions === true,
+    });
+    const target = targetPlanCatalog(databases, input.stableKeyName);
+    const stats = input.withStats ? await input.client.getDatabaseSchemaStats() : [];
+    const statsById = new Map(stats.map((entry) => [entry.databaseId, entry.size]));
+    const lock = readComponentLock(projectRoot);
+    const blockers = [];
+    const warnings = [];
+    const items = [];
+    let databasesWithActiveViewDependencies;
+    const localByKey = new Map();
+    const declaredLocalKeys = new Set();
+    for (const entry of localEntries) {
+        const stableKeyValue = isRecord(entry.manifest) ? entry.manifest.stableKey : undefined;
+        const missingStableKey = isRecord(entry.manifest)
+            && (!Object.hasOwn(entry.manifest, 'stableKey')
+                || stableKeyValue === null
+                || stableKeyValue === undefined
+                || (typeof stableKeyValue === 'string' && !stableKeyValue.trim()));
+        if (missingStableKey) {
+            items.push({
+                status: 'unmanaged',
+                name: typeof entry.manifest.name === 'string'
+                    ? entry.manifest.name
+                    : path.basename(path.dirname(entry.manifestPath)),
+                reason: `local WIP manifest is missing ${input.stableKeyName}`,
+                hints: ['This local WIP resource is non-blocking for ordinary planning; assign a Stable Key before it can be synchronized.'],
+            });
+            continue;
+        }
+        if (isRecord(entry.manifest) && typeof entry.manifest.stableKey === 'string' && entry.manifest.stableKey.trim()) {
+            declaredLocalKeys.add(entry.manifest.stableKey);
+        }
+        const errors = validatePlanManifest(entry.manifest, input.stableKeyName);
+        if (errors.length > 0) {
+            const relativePath = path.relative(projectRoot, entry.manifestPath);
+            blockers.push(`Invalid Database Schema manifest ${relativePath}: ${errors.join('; ')}.`);
+            items.push({
+                status: 'collision',
+                name: isRecord(entry.manifest) && typeof entry.manifest.name === 'string'
+                    ? entry.manifest.name
+                    : path.basename(path.dirname(entry.manifestPath)),
+                reason: 'invalid local manifest',
+                hints: ['Fix the manifest validation errors before planning or writing this resource.'],
+            });
+            continue;
+        }
+        localByKey.set(entry.manifest.stableKey, [...(localByKey.get(entry.manifest.stableKey) || []), entry]);
+    }
+    const targetByKey = new Map();
+    const managedTargetByName = new Map();
+    for (const entry of target.managed) {
+        targetByKey.set(entry.manifest.stableKey, [...(targetByKey.get(entry.manifest.stableKey) || []), entry]);
+        const name = physicalNameHint(entry.manifest);
+        managedTargetByName.set(name, [...(managedTargetByName.get(name) || []), entry]);
+    }
+    const unmanagedTargetByName = new Map();
+    for (const entry of target.unmanaged) {
+        const name = physicalNameHint(entry.record);
+        unmanagedTargetByName.set(name, [...(unmanagedTargetByName.get(name) || []), entry]);
+    }
+    const consumedTargetKeys = new Set();
+    const consumedUnmanaged = new Set();
+    const invalidLocalGraph = new Map();
+    const localKeysByPhysicalName = new Map();
+    for (const [stableKey, entries] of localByKey) {
+        if (entries.length !== 1) {
+            continue;
+        }
+        const name = physicalNameHint(entries[0].manifest);
+        localKeysByPhysicalName.set(name, [...(localKeysByPhysicalName.get(name) || []), stableKey]);
+    }
+    const duplicateLocalNames = new Set();
+    for (const [name, stableKeys] of localKeysByPhysicalName) {
+        if (stableKeys.length > 1) {
+            for (const stableKey of stableKeys) {
+                duplicateLocalNames.add(stableKey);
+            }
+            blockers.push(`Duplicate desired physical Database Schema name "${name}" for Stable Keys: ${stableKeys.sort().join(', ')}.`);
+        }
+    }
+    for (const [stableKey, entries] of localByKey) {
+        if (entries.length !== 1 || entries[0].manifest.kind !== 'database-partition') {
+            continue;
+        }
+        const parentStableKey = entries[0].manifest.parentStableKey;
+        if (!localByKey.has(parentStableKey)) {
+            invalidLocalGraph.set(stableKey, `parent "${parentStableKey}" is missing from the desired workspace`);
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visitParent = (stableKey, chain) => {
+        if (visiting.has(stableKey)) {
+            const cycleStart = chain.indexOf(stableKey);
+            for (const cycleKey of chain.slice(cycleStart)) {
+                invalidLocalGraph.set(cycleKey, 'desired partition parent cycle');
+            }
+            return;
+        }
+        if (visited.has(stableKey)) {
+            return;
+        }
+        const entries = localByKey.get(stableKey);
+        if (!entries || entries.length !== 1 || entries[0].manifest.kind !== 'database-partition') {
+            visited.add(stableKey);
+            return;
+        }
+        visiting.add(stableKey);
+        visitParent(entries[0].manifest.parentStableKey, [...chain, stableKey]);
+        visiting.delete(stableKey);
+        visited.add(stableKey);
+    };
+    for (const stableKey of localByKey.keys()) {
+        visitParent(stableKey, []);
+    }
+    for (const [stableKey, entries] of localByKey) {
+        const desired = portableDatabaseSchemaManifest(entries[0].manifest);
+        if (entries.length > 1) {
+            blockers.push(`Duplicate desired Database Schema stableKey "${stableKey}".`);
+            items.push({
+                status: 'collision', stableKey, name: desired.name, kind: desired.kind,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                reason: 'duplicate desired Stable Key', hints: ['Give each physical table or partition its own unique Stable Key.'],
+            });
+            continue;
+        }
+        if (duplicateLocalNames.has(stableKey)) {
+            items.push({
+                status: 'collision', stableKey, name: desired.name, kind: desired.kind,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                reason: 'duplicate desired physical table name',
+                hints: ['Choose a unique exact physical table name for each desired Stable Key before synchronization.'],
+            });
+            continue;
+        }
+        const graphError = invalidLocalGraph.get(stableKey);
+        if (graphError) {
+            blockers.push(`Invalid desired Database Schema graph for "${stableKey}": ${graphError}.`);
+            items.push({
+                status: 'collision', stableKey, name: desired.name, kind: desired.kind,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                reason: graphError, hints: ['Restore the complete parent chain and remove cycles before synchronizing this partition.'],
+            });
+            continue;
+        }
+        const matches = targetByKey.get(stableKey) || [];
+        const tombstone = lock.databaseSchemas[stableKey]?.environments[input.envName]?.tombstone;
+        if (desired.kind === 'database-partition' && tombstone) {
+            items.push({
+                status: 'previously-deleted-partition',
+                stableKey,
+                name: desired.name,
+                kind: desired.kind,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                desiredHash: hashPortableDatabaseSchema(desired),
+                reason: 'this Stable Key was previously deleted in the selected environment',
+                hints: ['Do not recreate or restore this partition automatically. Reuse this Stable Key only through an explicit reviewed restore workflow; create a physical replacement with a new Stable Key.'],
+            });
+            continue;
+        }
+        if (matches.length > 1) {
+            consumedTargetKeys.add(stableKey);
+            blockers.push(`Duplicate target Database Schema stableKey "${stableKey}".`);
+            items.push({
+                status: 'collision', stableKey, name: desired.name, kind: desired.kind,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                reason: 'duplicate target Stable Key', hints: ['Resolve the duplicate target metadata before synchronizing this resource.'],
+            });
+            continue;
+        }
+        const desiredName = physicalNameHint(desired);
+        const unmanagedNameCollisions = unmanagedTargetByName.get(desiredName) || [];
+        const managedNameCollisions = (managedTargetByName.get(desiredName) || [])
+            .filter(({ manifest }) => manifest.stableKey !== stableKey);
+        if (unmanagedNameCollisions.length > 0 || managedNameCollisions.length > 0) {
+            for (const collision of unmanagedNameCollisions) {
+                consumedUnmanaged.add(collision.record);
+            }
+            for (const collision of managedNameCollisions) {
+                consumedTargetKeys.add(collision.manifest.stableKey);
+            }
+            const reason = unmanagedNameCollisions.length > 0
+                ? `target Database Schema with the same physical name is unmanaged because it is missing ${input.stableKeyName}`
+                : `target Database Schema with the same physical name has a different ${input.stableKeyName}`;
+            items.push({
+                status: 'collision', stableKey, name: desired.name, kind: desired.kind, reason,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                desiredHash: hashPortableDatabaseSchema(desired),
+                hints: ['Assign and verify the intended Stable Key on the existing target table, or rename the desired physical table before creating it.'],
+            });
+            continue;
+        }
+        if (matches.length === 0) {
+            const sourceRestricted = lock.databaseSchemas[stableKey]?.sourceRestricted;
+            if (desired.kind === 'database-schema' && sourceRestricted !== false) {
+                items.push({
+                    status: 'access-policy-required',
+                    stableKey,
+                    name: desired.name,
+                    kind: desired.kind,
+                    reason: sourceRestricted === true
+                        ? 'source root table is restricted and target ACL principals are intentionally not portable'
+                        : 'source root access policy is unknown because the lock predates policy capture',
+                    desiredHash: hashPortableDatabaseSchema(desired),
+                    hints: [
+                        sourceRestricted === true
+                            ? 'Do not create this table without an explicit target access-policy decision. Configure target ACL principals through the target-local workflow before reconciling this resource.'
+                            : 'Pull the source again to capture its access policy before creating this root table on the target.',
+                    ],
+                });
+                continue;
+            }
+            const foreignReferences = desired.migration?.foreignReferences === 'manual'
+                || hasForeignReferences(desired.definition || []);
+            items.push({
+                status: foreignReferences ? 'manual-schema-migration-required' : 'create',
+                stableKey,
+                name: desired.name,
+                kind: desired.kind,
+                ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+                reason: foreignReferences ? 'foreign references require manual deployment and verification' : 'desired resource is missing on target',
+                desiredHash: hashPortableDatabaseSchema(desired),
+                changes: foreignReferences ? [{
+                        kind: 'foreign-reference', field: 'definition.foreignReferences', risk: 'manual',
+                        hint: 'Create the table and enforce or verify its foreign relationships through an explicit migration; the API does not create SQL foreign-key constraints.',
+                    }] : undefined,
+                hints: [foreignReferences
+                        ? 'Create and verify this table through a reviewed migration before reconciling its Stable Key.'
+                        : desired.kind === 'database-partition'
+                            ? 'Create this partition only after its target parent exists, then verify its portable hash before recording the target lock baseline.'
+                            : 'Create this root table without records, verify its portable hash, then record the target lock baseline.'],
+            });
+            continue;
+        }
+        consumedTargetKeys.add(stableKey);
+        const current = matches[0];
+        const desiredHash = hashPortableDatabaseSchema(desired);
+        const changes = diffDatabaseSchemas(desired, current.manifest, input.stableKeyName);
+        if (changes.some((change) => change.kind === 'column-renamed')) {
+            if (!databasesWithActiveViewDependencies) {
+                const views = await input.client.listAllDatabaseViews();
+                databasesWithActiveViewDependencies = new Set(views
+                    .filter((view) => !view.deletedAt)
+                    .flatMap((view) => Array.isArray(view.sourceDatabaseIds) ? view.sourceDatabaseIds : []));
+            }
+            if (databasesWithActiveViewDependencies.has(current.databaseId)) {
+                changes.push({
+                    kind: 'database-view-dependency',
+                    field: 'databaseViews',
+                    risk: 'manual',
+                    hint: 'An active Database View depends on this table. Update the view and validate its fields through an explicit reviewed migration before renaming a column.',
+                });
+            }
+        }
+        if (changes.length > 0 && desired.kind === 'database-schema' && current.record.audit === true) {
+            changes.push({
+                kind: 'audit-trigger-rebuild',
+                field: 'audit',
+                risk: 'operational',
+                hint: 'This target has audit enabled, so the API rebuilds its audit trigger during the update. Writes are serialized and retried once only after a fresh live hash and version check.',
+            });
+        }
+        const changedFields = [...new Set(changes.map((change) => change.field))];
+        const baselineHash = lock.databaseSchemas[stableKey]?.environments[input.envName]?.remoteHash;
+        const currentStats = statsById.get(current.databaseId);
+        const sizeHint = changes.length > 0 ? sizeRiskHint(currentStats) : undefined;
+        const common = {
+            stableKey,
+            name: desired.name,
+            kind: desired.kind,
+            ...(desired.parentStableKey ? { parentStableKey: desired.parentStableKey } : {}),
+            desiredHash,
+            currentHash: current.hash,
+            ...(baselineHash ? { baselineHash } : {}),
+            ...(changes.length > 0 ? { changes, changedFields } : {}),
+            hints: [...changes.map((change) => change.hint), ...(sizeHint ? [sizeHint] : [])],
+            ...(currentStats ? { stats: currentStats } : {}),
+        };
+        const columnStableKeyValidationFailed = changes.some((change) => (change.risk === 'manual'
+            && change.kind === 'column-changed'
+            && change.field.includes(`.metadata.${input.stableKeyName}`)));
+        if (columnStableKeyValidationFailed) {
+            items.push({
+                ...common,
+                status: 'manual-schema-migration-required',
+                reason: 'one or more column Stable Keys are malformed or duplicated',
+            });
+            continue;
+        }
+        if (desiredHash === current.hash) {
+            if (!baselineHash) {
+                items.push({
+                    ...common,
+                    status: 'missing-lock',
+                    reason: `desired and target match, but the ${input.envName} lock baseline is missing`,
+                    hints: ['Adopt this verified live match through the push workflow so the selected environment receives its own lock baseline.'],
+                });
+            }
+            else if (baselineHash !== current.hash) {
+                items.push({
+                    ...common,
+                    status: 'reconciled',
+                    reason: 'desired and target match after a manual or external change; lock baseline is stale',
+                    hints: ['The live portable hash is converged; a later verified push may advance only this environment lock baseline.'],
+                });
+            }
+            else {
+                items.push({ ...common, status: 'clean' });
+            }
+            continue;
+        }
+        const partitionBoundsChanged = desired.kind === 'database-partition'
+            && current.manifest.kind === 'database-partition'
+            && !valuesEqual(desired.partition, current.manifest.partition);
+        if (partitionBoundsChanged) {
+            items.push({
+                ...common,
+                status: 'replacement-requires-two-phases',
+                reason: 'partition bounds changed under an existing Stable Key',
+                hints: ['Partition bounds are immutable. Keep the old Stable Key only for an explicit reviewed restore; prune the old physical partition, then create its replacement with a new Stable Key in a later push.'],
+            });
+            continue;
+        }
+        if (changes.some((change) => change.risk === 'manual')) {
+            items.push({
+                ...common,
+                status: 'manual-schema-migration-required',
+                reason: 'one or more changes require an explicit DDL or data migration',
+            });
+        }
+        else if (!baselineHash) {
+            items.push({ ...common, status: 'missing-lock', reason: `missing ${input.envName} lock baseline` });
+        }
+        else if (desiredHash === baselineHash) {
+            items.push({ ...common, status: 'remote-changed', reason: 'target changed since lock baseline' });
+        }
+        else if (current.hash === baselineHash) {
+            items.push({ ...common, status: 'safe-update' });
+        }
+        else {
+            items.push({ ...common, status: 'conflict', reason: 'desired and target changed since lock baseline' });
+        }
+    }
+    for (const [stableKey, matches] of targetByKey) {
+        if (consumedTargetKeys.has(stableKey) || declaredLocalKeys.has(stableKey)) {
+            continue;
+        }
+        if (matches.length > 1) {
+            blockers.push(`Duplicate target Database Schema stableKey "${stableKey}".`);
+            items.push({
+                status: 'collision', stableKey, name: matches[0].manifest.name, kind: matches[0].manifest.kind,
+                ...(matches[0].manifest.parentStableKey ? { parentStableKey: matches[0].manifest.parentStableKey } : {}),
+                reason: 'duplicate target Stable Key', hints: ['Resolve the duplicate target metadata before synchronizing this resource.'],
+            });
+            continue;
+        }
+        const current = matches[0];
+        const isPartition = current.manifest.kind === 'database-partition';
+        const lockEntry = lock.databaseSchemas[stableKey];
+        const wasManagedPartition = isPartition
+            && Boolean(lockEntry?.parentStableKey)
+            && Boolean(lockEntry?.environments[input.envName]?.remoteHash)
+            && !lockEntry?.environments[input.envName]?.tombstone;
+        const currentStats = statsById.get(current.databaseId);
+        const deletionSizeHint = wasManagedPartition ? sizeRiskHint(currentStats) : undefined;
+        items.push({
+            status: isPartition && lockEntry?.environments[input.envName]?.tombstone
+                ? 'previously-deleted-partition'
+                : wasManagedPartition
+                    ? 'delete-partition'
+                    : isPartition ? 'orphan-partition' : 'orphan-root',
+            stableKey,
+            name: current.manifest.name,
+            kind: current.manifest.kind,
+            ...(current.manifest.parentStableKey ? { parentStableKey: current.manifest.parentStableKey } : {}),
+            currentHash: current.hash,
+            reason: isPartition && lockEntry?.environments[input.envName]?.tombstone
+                ? 'a partition with this Stable Key reappeared after its recorded deletion'
+                : wasManagedPartition
+                    ? 'previously managed partition manifest was removed locally'
+                    : `target-only ${isPartition ? 'partition' : 'root schema'} remains untouched`,
+            hints: [isPartition && lockEntry?.environments[input.envName]?.tombstone
+                    ? 'Do not restore or delete this resource automatically. Resolve the tombstone through an explicit reviewed lifecycle operation.'
+                    : wasManagedPartition
+                        ? 'Before deletion, check dependent Database Views, back up or migrate rows, verify the full descendant branch, then use the dedicated forced partition prune flow leaves-first.'
+                        : 'Target-only resources are informational and are never deleted automatically by a general schema plan.',
+                ...(deletionSizeHint ? [deletionSizeHint] : [])],
+            ...(currentStats ? { stats: currentStats } : {}),
+        });
+    }
+    const createdPartitions = items.filter((item) => item.status === 'create' && item.kind === 'database-partition');
+    const deletedPartitions = items.filter((item) => item.status === 'delete-partition');
+    for (const created of createdPartitions) {
+        const desired = localByKey.get(created.stableKey || '')?.[0]?.manifest;
+        if (!desired || !created.parentStableKey) {
+            continue;
+        }
+        for (const deleted of deletedPartitions) {
+            const current = targetByKey.get(deleted.stableKey || '')?.[0]?.manifest;
+            if (!current
+                || current.parentStableKey !== created.parentStableKey
+                || !partitionBoundsOverlap(desired.partition, current.partition)) {
+                continue;
+            }
+            const reason = 'overlapping partition replacement requires delete and create in two separate pushes';
+            const hints = ['First prune the old partition with --prune-partitions --yes --force and verify its tombstone. Then create the replacement with a new Stable Key in a later push.'];
+            created.status = 'replacement-requires-two-phases';
+            created.reason = reason;
+            created.hints = hints;
+            deleted.status = 'replacement-requires-two-phases';
+            deleted.reason = reason;
+            deleted.hints = hints;
+        }
+    }
+    for (const unmanaged of target.unmanaged) {
+        if (consumedUnmanaged.has(unmanaged.record)) {
+            continue;
+        }
+        const databaseId = databaseIdOf(unmanaged.record);
+        items.push({
+            status: 'unmanaged',
+            name: String(unmanaged.record.name || databaseId || 'unknown'),
+            reason: unmanaged.reason,
+            hints: ['This WIP resource is non-blocking for ordinary planning; assign a Stable Key when it should become managed.'],
+            ...(statsById.has(databaseId) ? { stats: statsById.get(databaseId) } : {}),
+        });
+    }
+    const rank = {
+        create: 0,
+        'safe-update': 1,
+        'manual-schema-migration-required': 2,
+        'access-policy-required': 3,
+        'remote-changed': 4,
+        conflict: 5,
+        'missing-lock': 6,
+        reconciled: 7,
+        clean: 8,
+        'delete-partition': 9,
+        'previously-deleted-partition': 10,
+        'replacement-requires-two-phases': 11,
+        'orphan-partition': 12,
+        'orphan-root': 13,
+        unmanaged: 14,
+        collision: 15,
+    };
+    items.sort((left, right) => rank[left.status] - rank[right.status]
+        || (left.stableKey || left.name).localeCompare(right.stableKey || right.name));
+    const counts = emptyPlanCounts();
+    for (const item of items) {
+        counts[item.status] += 1;
+    }
+    if (!input.withStats) {
+        warnings.push('Table sizes were not fetched; use --with-stats for one cached bulk size request and more concrete DDL risk context.');
+    }
+    return {
+        resourceType: 'database-schema',
+        env: input.envName,
+        withStats: Boolean(input.withStats),
+        skipPartitions: input.skipPartitions === true,
+        counts,
+        blockers: [...new Set(blockers)].sort((left, right) => left.localeCompare(right)),
+        warnings,
+        exclusions: [
+            'audit configuration and audit history are target-local',
+            'ACL users, groups, and restricted policy are target-local',
+            'tags are target-local',
+            'root schemas and unknown target-only partitions are never deleted by plan',
+            ...(input.skipPartitions === true
+                ? ['partitions were excluded from this root-schema-only plan']
+                : []),
+        ],
+        items,
+    };
+}
+function validateCatalog(records, stableKeyName, envName) {
+    const migratableRecords = excludeDatabaseBackupArtifacts(records);
+    const allIds = new Set();
+    const idsByName = new Map();
+    for (const record of migratableRecords) {
+        const id = databaseIdOf(record);
+        if (!id) {
+            throw new Error('Database schema without databaseId was returned; no files were changed.');
+        }
+        allIds.add(id);
+        const name = String(record.name || '');
+        idsByName.set(name, [...(idsByName.get(name) || []), id]);
+    }
+    const entriesById = new Map();
+    const entriesByKey = new Map();
+    const skipped = [];
+    for (const record of migratableRecords) {
+        const id = databaseIdOf(record);
+        if (!id) {
+            throw new Error('Database schema without databaseId was returned; no files were changed.');
+        }
+        const raw = rawStableKey(record, stableKeyName);
+        if (raw.present && (typeof raw.value !== 'string' || !raw.value.trim())) {
+            throw new Error(`Invalid database-schema stableKey on ${id}; no files were changed.`);
+        }
+        const stableKey = configuredStableKey(record, stableKeyName);
+        if (!stableKey) {
+            skipped.push({ targetPath: label(record), reason: `unmanaged: missing ${stableKeyName}` });
+            continue;
+        }
+        if (entriesByKey.has(stableKey)) {
+            throw new Error(`Duplicate database-schema stableKey "${stableKey}" on ${envName}; no files were changed.`);
+        }
+        const entry = { record, id, stableKey, parentId: null };
+        entriesById.set(id, entry);
+        entriesByKey.set(stableKey, entry);
+    }
+    for (const entry of entriesById.values()) {
+        const resolvedParents = new Set();
+        for (const reference of parentCandidates(entry.record)) {
+            if (reference.kind === 'id') {
+                resolvedParents.add(reference.value);
+                continue;
+            }
+            const matches = idsByName.get(reference.value) || [];
+            if (matches.length > 1) {
+                throw new Error(`Ambiguous parent "${reference.value}" for database schema "${entry.stableKey}"; no files were changed.`);
+            }
+            if (matches.length === 1) {
+                resolvedParents.add(matches[0]);
+            }
+            else {
+                resolvedParents.add(reference.value);
+            }
+        }
+        if (resolvedParents.size > 1) {
+            throw new Error(`Ambiguous parent for database schema "${entry.stableKey}"; no files were changed.`);
+        }
+        entry.parentId = [...resolvedParents][0] || null;
+    }
+    const unmanagedParentIds = new Set();
+    let exclusionsChanged = true;
+    while (exclusionsChanged) {
+        exclusionsChanged = false;
+        for (const entry of entriesById.values()) {
+            if (!entry.parentId || unmanagedParentIds.has(entry.id)) {
+                continue;
+            }
+            if (!allIds.has(entry.parentId)) {
+                throw new Error(`Database schema "${entry.stableKey}" has a missing parent; no files were changed.`);
+            }
+            if (!entriesById.has(entry.parentId) || unmanagedParentIds.has(entry.parentId)) {
+                unmanagedParentIds.add(entry.id);
+                skipped.push({
+                    targetPath: label(entry.record),
+                    reason: `unmanaged: parent is missing ${stableKeyName}`,
+                });
+                exclusionsChanged = true;
+            }
+        }
+    }
+    for (const id of unmanagedParentIds) {
+        const entry = entriesById.get(id);
+        if (entry) {
+            entriesByKey.delete(entry.stableKey);
+        }
+        entriesById.delete(id);
+    }
+    for (const entry of entriesById.values()) {
+        if (!entry.parentId) {
+            continue;
+        }
+        const parent = entriesById.get(entry.parentId);
+        if (!parent) {
+            throw new Error(`Database schema "${entry.stableKey}" has a missing parent; no files were changed.`);
+        }
+        entry.parentStableKey = parent.stableKey;
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (entry) => {
+        if (visiting.has(entry.id)) {
+            throw new Error(`Database-schema parent cycle detected at "${entry.stableKey}"; no files were changed.`);
+        }
+        if (visited.has(entry.id)) {
+            return;
+        }
+        visiting.add(entry.id);
+        if (entry.parentId) {
+            visit(entriesById.get(entry.parentId));
+        }
+        visiting.delete(entry.id);
+        visited.add(entry.id);
+    };
+    for (const entry of entriesById.values()) {
+        visit(entry);
+    }
+    return { entries: [...entriesById.values()], entriesById, skipped };
+}
+export async function pullDatabaseSchemasToWorkspace(input) {
+    const { projectRoot, workspaceRoot } = requireProjectLayout(input.cwd, 'Database Schema');
+    const { databases } = await input.client.listAllDatabaseSchemas({ projection: 'pull' });
+    const catalog = validateCatalog(databases, input.stableKeyName, input.envName);
+    if (input.strict && catalog.skipped.length > 0) {
+        throw new Error(`Database Schema strict pull requires Stable Keys on all active resources; ${catalog.skipped.length} unmanaged resource(s) found.`);
+    }
+    const manifestsById = new Map(catalog.entries.map((entry) => [entry.id, manifestFromEntry(entry, input.stableKeyName)]));
+    const pathsById = new Map();
+    const resolvePath = (entry) => {
+        const existing = pathsById.get(entry.id);
+        if (existing) {
+            return existing;
+        }
+        const manifest = manifestsById.get(entry.id);
+        const filePath = entry.parentId
+            ? path.join(path.dirname(resolvePath(catalog.entriesById.get(entry.parentId))), 'Partitions', `${sanitizeSegment(manifest.name)}-${stableKeySuffix(manifest.stableKey)}`, DATABASE_SCHEMA_MANIFEST_FILE)
+            : rootManifestPath(workspaceRoot, manifest);
+        pathsById.set(entry.id, filePath);
+        return filePath;
+    };
+    const existingByKey = new Map();
+    const catalogPathOwners = new Map();
+    for (const entry of catalog.entries) {
+        const identity = pathIdentity(resolvePath(entry));
+        const owner = catalogPathOwners.get(identity);
+        if (owner && owner !== entry.stableKey) {
+            throw new Error(`Database Schema workspace path collision for "${entry.stableKey}" and "${owner}"; no files were changed.`);
+        }
+        catalogPathOwners.set(identity, entry.stableKey);
+    }
+    for (const local of loadWorkspaceManifests(workspaceRoot)) {
+        if (!isRecord(local.manifest) || typeof local.manifest.stableKey !== 'string') {
+            throw new Error(`Invalid database-schema manifest ${path.relative(projectRoot, local.manifestPath)}; no files were changed.`);
+        }
+        if (existingByKey.has(local.manifest.stableKey)) {
+            throw new Error(`Duplicate local database-schema stableKey "${local.manifest.stableKey}"; no files were changed.`);
+        }
+        existingByKey.set(local.manifest.stableKey, local);
+    }
+    const lock = readComponentLock(projectRoot);
+    const skipped = [...catalog.skipped];
+    const writes = [];
+    const sourceStableKeys = new Set(catalog.entries.map((entry) => entry.stableKey));
+    const pruned = input.pruneOrphans === true
+        ? [...existingByKey.values()]
+            .filter((local) => !sourceStableKeys.has(local.manifest.stableKey))
+            .map((local) => ({
+            stableKey: local.manifest.stableKey,
+            targetPath: localTargetPath(input.cwd, local.manifestPath),
+            manifestPath: local.manifestPath,
+        }))
+            .sort((left, right) => right.manifestPath.length - left.manifestPath.length || left.stableKey.localeCompare(right.stableKey))
+        : [];
+    for (const entry of catalog.entries) {
+        const manifest = manifestsById.get(entry.id);
+        const hash = hashPortableDatabaseSchema(manifest);
+        const existing = existingByKey.get(entry.stableKey);
+        if (existing && !input.force) {
+            const localHash = hashPortableDatabaseSchema(existing.manifest);
+            const baseline = lock.databaseSchemas[entry.stableKey];
+            if (localHash !== hash && (!baseline || localHash !== baseline.sourceHash)) {
+                skipped.push({
+                    targetPath: localTargetPath(input.cwd, existing.manifestPath),
+                    reason: 'local manifest changed since the lock baseline; use --force to overwrite',
+                });
+                continue;
+            }
+        }
+        writes.push({
+            manifest,
+            hash,
+            filePath: resolvePath(entry),
+            ...(entry.parentId || typeof entry.record.restricted !== 'boolean'
+                ? {}
+                : { sourceRestricted: entry.record.restricted }),
+            ...(existing ? { previousPath: existing.manifestPath } : {}),
+        });
+    }
+    const pathOwners = new Map();
+    for (const write of writes) {
+        const identity = pathIdentity(write.filePath);
+        const owner = pathOwners.get(identity);
+        if (owner && owner !== write.manifest.stableKey) {
+            throw new Error(`Database Schema workspace path collision for "${write.manifest.stableKey}" and "${owner}"; no files were changed.`);
+        }
+        pathOwners.set(identity, write.manifest.stableKey);
+        if (fs.existsSync(write.filePath)) {
+            const local = readJsonFile(write.filePath);
+            if (local.stableKey !== write.manifest.stableKey) {
+                throw new Error(`Database Schema workspace path is occupied by "${String(local.stableKey)}"; no files were changed.`);
+            }
+        }
+    }
+    for (const write of writes.sort((left, right) => left.manifest.stableKey.localeCompare(right.manifest.stableKey))) {
+        writePulledManifest({
+            filePath: write.filePath,
+            manifest: write.manifest,
+            previousPath: write.previousPath,
+            root: path.join(workspaceRoot, DATABASE_SCHEMAS_DIRECTORY),
+            force: input.force,
+        });
+        const previous = lock.databaseSchemas[write.manifest.stableKey];
+        const entry = {
+            stableKey: write.manifest.stableKey,
+            path: toPortableRelativePath(projectRoot, write.filePath),
+            sourceHash: write.hash,
+            ...(typeof write.sourceRestricted === 'boolean' ? { sourceRestricted: write.sourceRestricted } : {}),
+            ...(write.manifest.parentStableKey ? { parentStableKey: write.manifest.parentStableKey } : {}),
+            environments: {
+                ...(previous?.environments || {}),
+                [input.envName]: {
+                    remoteHash: write.hash,
+                },
+            },
+        };
+        lock.databaseSchemas[write.manifest.stableKey] = entry;
+    }
+    for (const removed of pruned) {
+        removeRelocatedManifest(removed.manifestPath, path.join(workspaceRoot, DATABASE_SCHEMAS_DIRECTORY));
+        delete lock.databaseSchemas[removed.stableKey];
+    }
+    if (writes.length > 0 || pruned.length > 0) {
+        writeComponentLock(projectRoot, lock);
+    }
+    return {
+        pulled: writes.map((write) => ({
+            manifest: write.manifest,
+            targetPath: localTargetPath(input.cwd, write.filePath),
+        })),
+        pruned: pruned
+            .map(({ stableKey, targetPath }) => ({ stableKey, targetPath }))
+            .sort((left, right) => left.stableKey.localeCompare(right.stableKey)),
+        skipped: skipped.sort((left, right) => left.targetPath.localeCompare(right.targetPath)),
+        diagnostics: catalog.entries.map((entry) => ({
+            stableKey: entry.stableKey,
+            ...(entry.record.audit === undefined ? {} : { audit: entry.record.audit }),
+            ...(entry.record.restricted !== undefined
+                ? { acl: { restricted: entry.record.restricted } }
+                : {}),
+            ...(entry.record.tags === undefined ? {} : { tags: entry.record.tags }),
+        })),
+    };
+}
+class PartitionParentUnavailableError extends Error {
+}
+function readWorkspaceDatabaseSchemasForPush(cwd, stableKeyName) {
+    const { workspaceRoot } = requireProjectLayout(cwd, 'Database Schema');
+    const entriesByKey = new Map();
+    for (const entry of loadWorkspaceManifests(workspaceRoot)) {
+        const errors = validatePlanManifest(entry.manifest, stableKeyName);
+        if (errors.length > 0) {
+            continue;
+        }
+        entriesByKey.set(entry.manifest.stableKey, [
+            ...(entriesByKey.get(entry.manifest.stableKey) || []),
+            entry,
+        ]);
+    }
+    return new Map([...entriesByKey]
+        .filter(([, entries]) => entries.length === 1)
+        .map(([stableKey, entries]) => [stableKey, entries[0]]));
+}
+function createPayloadForDatabaseSchema(input) {
+    const common = {
+        name: input.manifest.name,
+        ...(input.manifest.category === undefined ? {} : { category: input.manifest.category }),
+        ...(input.manifest.description === undefined ? {} : { desc: input.manifest.description }),
+        metadata: sanitizeUserMetadata(input.manifest.metadata),
+    };
+    if (input.manifest.kind === 'database-partition') {
+        if (!input.parentName) {
+            throw new PartitionParentUnavailableError('target parent is missing or ambiguous');
+        }
+        return {
+            ...common,
+            parent: input.parentName,
+            partition: canonicalValue(input.manifest.partition || {}, true),
+        };
+    }
+    return {
+        ...common,
+        definition: portableDefinitions(input.manifest.definition),
+        ...(input.manifest.partition === undefined
+            ? {}
+            : { partition: canonicalValue(input.manifest.partition, true) }),
+        audit: false,
+        restricted: false,
+    };
+}
+function createItemsInDependencyOrder(items, localByKey) {
+    const itemsByKey = new Map(items
+        .filter((item) => typeof item.stableKey === 'string')
+        .map((item) => [item.stableKey, item]));
+    const ordered = [];
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (stableKey) => {
+        if (visited.has(stableKey) || visiting.has(stableKey)) {
+            return;
+        }
+        visiting.add(stableKey);
+        const parentStableKey = localByKey.get(stableKey)?.manifest.parentStableKey;
+        if (parentStableKey && itemsByKey.has(parentStableKey)) {
+            visit(parentStableKey);
+        }
+        visiting.delete(stableKey);
+        visited.add(stableKey);
+        const item = itemsByKey.get(stableKey);
+        if (item) {
+            ordered.push(item);
+        }
+    };
+    for (const stableKey of [...itemsByKey.keys()].sort((left, right) => left.localeCompare(right))) {
+        visit(stableKey);
+    }
+    return ordered;
+}
+function currentTargetParentName(input) {
+    const catalog = targetPlanCatalog(input.records, input.stableKeyName);
+    const matches = catalog.managed.filter((entry) => entry.manifest.stableKey === input.parentStableKey);
+    if (matches.length !== 1) {
+        throw new PartitionParentUnavailableError(`target parent "${input.parentStableKey}" is missing or ambiguous`);
+    }
+    const parentName = matches[0].manifest.name;
+    if (!parentName) {
+        throw new PartitionParentUnavailableError(`target parent "${input.parentStableKey}" has no physical name`);
+    }
+    return parentName;
+}
+async function recheckDatabaseSchemaCreate(input) {
+    const [stableKeyMatchRecords, matchingNameRecords] = await Promise.all([
+        input.client.findActiveDatabaseSchemasByField('metadata', input.manifest.stableKey, [input.stableKeyName]),
+        input.client.findActiveDatabaseSchemasByField('name', input.manifest.name),
+    ]);
+    const stableKeyMatches = excludeDatabaseBackupArtifacts(stableKeyMatchRecords);
+    const matchingNames = excludeDatabaseBackupArtifacts(matchingNameRecords);
+    if (stableKeyMatches.length > 0) {
+        throw new Error('matching Stable Key appeared after planning');
+    }
+    if (matchingNames.length > 0) {
+        throw new Error(`unmanaged-name-conflict: target table "${input.manifest.name}" appeared after planning`);
+    }
+    let records = input.records;
+    if (input.manifest.kind === 'database-partition') {
+        const parentStableKey = input.manifest.parentStableKey || '';
+        const parents = excludeDatabaseBackupArtifacts(await input.client.findActiveDatabaseSchemasByField('metadata', parentStableKey, [input.stableKeyName]));
+        if (parents.length !== 1) {
+            throw new PartitionParentUnavailableError(`target parent "${parentStableKey}" is missing or ambiguous`);
+        }
+        records = replaceDatabaseSchemaRecord(records, parents[0]);
+    }
+    const migratableDatabases = excludeDatabaseBackupArtifacts(records);
+    const parentName = input.manifest.kind === 'database-partition'
+        ? currentTargetParentName({
+            records: migratableDatabases,
+            stableKeyName: input.stableKeyName,
+            parentStableKey: input.manifest.parentStableKey || '',
+        })
+        : undefined;
+    return { databases: migratableDatabases, parentName };
+}
+function verifyCreatedDatabaseSchema(input) {
+    const verifiedStableKey = configuredStableKey(input.created, input.stableKeyName);
+    if (verifiedStableKey !== input.desired.stableKey) {
+        throw new Error(`written target is missing or changed ${input.stableKeyName}`);
+    }
+    const createdId = databaseIdOf(input.created);
+    const records = [
+        ...input.recordsBeforeCreate.filter((record) => databaseIdOf(record) !== createdId),
+        input.created,
+    ];
+    const catalog = targetPlanCatalog(records, input.stableKeyName);
+    const verified = catalog.managed.filter((entry) => entry.databaseId === createdId);
+    if (verified.length !== 1) {
+        throw new Error('created target could not be resolved into the live partition graph');
+    }
+    const remoteHash = verified[0].hash;
+    const desiredHash = hashPortableDatabaseSchema(input.desired);
+    if (remoteHash !== desiredHash) {
+        throw new Error(`created target did not match desired portable hash (desired: ${desiredHash}; actual: ${remoteHash})`);
+    }
+    return remoteHash;
+}
+function updateDatabaseSchemaEnvironmentBaseline(input) {
+    const { projectRoot } = requireProjectLayout(input.cwd, 'Database Schema');
+    const lock = readComponentLock(projectRoot);
+    const existing = lock.databaseSchemas[input.manifest.stableKey];
+    const entry = {
+        stableKey: input.manifest.stableKey,
+        path: toPortableRelativePath(projectRoot, input.manifestPath),
+        sourceHash: hashPortableDatabaseSchema(input.manifest),
+        ...(input.manifest.kind === 'database-schema' && typeof existing?.sourceRestricted === 'boolean'
+            ? { sourceRestricted: existing.sourceRestricted }
+            : {}),
+        ...(input.manifest.parentStableKey ? { parentStableKey: input.manifest.parentStableKey } : {}),
+        environments: {
+            ...(existing?.environments || {}),
+            [input.envName]: { remoteHash: input.remoteHash },
+        },
+    };
+    lock.databaseSchemas[input.manifest.stableKey] = entry;
+    writeComponentLock(projectRoot, lock);
+}
+function resolveDatabaseSchemaManifestFromRecords(input) {
+    const catalog = targetPlanCatalog(input.records, input.stableKeyName);
+    const matches = catalog.managed.filter((entry) => (entry.databaseId === input.databaseId && entry.manifest.stableKey === input.stableKey));
+    if (matches.length !== 1) {
+        throw new Error('live target could not be resolved into an unambiguous managed database schema');
+    }
+    return matches[0];
+}
+async function resolveLiveDatabaseSchemaWriteTarget(input) {
+    const records = excludeDatabaseBackupArtifacts(input.records);
+    const matches = records.filter((record) => configuredStableKey(record, input.stableKeyName) === input.stableKey);
+    if (matches.length !== 1) {
+        throw new Error(`expected one live target Database Schema match, found ${matches.length}`);
+    }
+    const databaseId = databaseIdOf(matches[0]);
+    if (!databaseId) {
+        throw new Error('live target Database Schema did not include databaseId');
+    }
+    const record = unwrapData(await input.client.getDatabaseSchema(databaseId));
+    if (configuredStableKey(record, input.stableKeyName) !== input.stableKey) {
+        throw new Error(`live target Database Schema is missing or changed ${input.stableKeyName}`);
+    }
+    if (databaseIdOf(record) !== databaseId) {
+        throw new Error('live target Database Schema identity changed before write');
+    }
+    if (typeof record.version !== 'number') {
+        throw new Error('live target Database Schema did not include a current version');
+    }
+    const freshRecords = records.map((candidate) => databaseIdOf(candidate) === databaseId ? record : candidate);
+    const resolved = resolveDatabaseSchemaManifestFromRecords({
+        records: freshRecords,
+        databaseId,
+        stableKey: input.stableKey,
+        stableKeyName: input.stableKeyName,
+    });
+    if (resolved.hash !== input.expectedHash) {
+        throw new Error('target Database Schema changed after planning');
+    }
+    return {
+        databaseId,
+        record,
+        manifest: resolved.manifest,
+        hash: resolved.hash,
+        records: freshRecords,
+    };
+}
+function replaceDatabaseSchemaRecord(records, replacement) {
+    const databaseId = databaseIdOf(replacement);
+    if (!databaseId) {
+        throw new Error('target Database Schema did not include databaseId');
+    }
+    const existing = records.some((record) => databaseIdOf(record) === databaseId);
+    return existing
+        ? records.map((record) => (databaseIdOf(record) === databaseId ? replacement : record))
+        : [...records, replacement];
+}
+function buildDatabaseSchemaUpdatePayload(input) {
+    if (typeof input.target.version !== 'number') {
+        throw new Error('live target Database Schema did not include a current version');
+    }
+    const payload = {
+        version: input.target.version,
+        metadata: sanitizeUserMetadata(input.desired.metadata),
+        ...(typeof input.desired.category === 'string' ? { category: input.desired.category } : {}),
+        ...(input.desired.description === undefined
+            ? (typeof input.target.desc === 'string' && input.target.desc ? { desc: '' } : {})
+            : { desc: input.desired.description }),
+    };
+    if (input.desired.kind === 'database-partition') {
+        return payload;
+    }
+    const targetDefinitions = Array.isArray(input.target.definition)
+        ? input.target.definition.filter(isRecord)
+        : [];
+    const targetDefinitionsByName = new Map();
+    for (const definition of targetDefinitions) {
+        const name = typeof definition.name === 'string' ? definition.name : '';
+        targetDefinitionsByName.set(name, [...(targetDefinitionsByName.get(name) || []), definition]);
+    }
+    const stableKeyName = input.stableKeyName || 'stableKey';
+    const targetDefinitionsByStableKey = new Map();
+    for (const definition of targetDefinitions) {
+        const stableKey = columnStableKey(portableDefinition(definition), stableKeyName);
+        if (stableKey) {
+            targetDefinitionsByStableKey.set(stableKey, [...(targetDefinitionsByStableKey.get(stableKey) || []), definition]);
+        }
+    }
+    const desiredStableKeyOwners = new Map();
+    for (const definition of input.desired.definition || []) {
+        const stableKey = columnStableKey(definition, stableKeyName);
+        if (stableKey) {
+            desiredStableKeyOwners.set(stableKey, [...(desiredStableKeyOwners.get(stableKey) || []), definition]);
+        }
+    }
+    payload.definition = (input.desired.definition || []).map((definition) => {
+        const value = portableDefinition(definition);
+        const stableKey = columnStableKey(value, stableKeyName);
+        const stableKeyTargets = stableKey ? targetDefinitionsByStableKey.get(stableKey) || [] : [];
+        if (stableKey && (stableKeyTargets.length > 1 || (desiredStableKeyOwners.get(stableKey) || []).length > 1)) {
+            throw new Error(`column Stable Key "${stableKey}" is duplicated; refusing to update Database Schema definitions`);
+        }
+        const namedTargets = targetDefinitionsByName.get(columnName(value)) || [];
+        const namedTarget = namedTargets.length === 1 ? namedTargets[0] : undefined;
+        const canUseLegacyNameMatch = Boolean(namedTarget) && (!stableKey || !columnStableKey(portableDefinition(namedTarget), stableKeyName));
+        const targetDefinition = stableKey
+            ? stableKeyTargets[0] || (canUseLegacyNameMatch ? namedTarget : undefined)
+            : canUseLegacyNameMatch ? namedTarget : undefined;
+        if (!targetDefinition) {
+            return value;
+        }
+        if (typeof targetDefinition.databaseDefinitionId !== 'string' || !targetDefinition.databaseDefinitionId) {
+            throw new Error(`live target column "${columnName(value)}" did not include databaseDefinitionId`);
+        }
+        return { ...value, databaseDefinitionId: targetDefinition.databaseDefinitionId };
+    });
+    return payload;
+}
+function verifyDatabaseSchemaWrite(input) {
+    const databaseId = databaseIdOf(input.record);
+    if (!databaseId) {
+        throw new Error('verified target did not include databaseId');
+    }
+    if (configuredStableKey(input.record, input.stableKeyName) !== input.desired.stableKey) {
+        throw new Error(`written target is missing or changed ${input.stableKeyName}`);
+    }
+    const records = input.recordsBeforeWrite.map((candidate) => (databaseIdOf(candidate) === databaseId ? input.record : candidate));
+    const verified = resolveDatabaseSchemaManifestFromRecords({
+        records,
+        databaseId,
+        stableKey: input.desired.stableKey,
+        stableKeyName: input.stableKeyName,
+    });
+    const desiredHash = hashPortableDatabaseSchema(input.desired);
+    if (verified.hash !== desiredHash) {
+        throw new Error(`written target did not match desired portable hash (desired: ${desiredHash}; actual: ${verified.hash})`);
+    }
+    return verified.hash;
+}
+function isRetriableAuditedDatabaseSchemaWrite(error, target) {
+    if (error instanceof ApiError && error.status === 429) {
+        return true;
+    }
+    if (target.audit !== true) {
+        return false;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /audit configuration is busy|retry the save operation|newer version/i.test(message);
+}
+const DATABASE_SCHEMA_MUTATION_INTERVAL_MS = 110;
+const AUDITED_DATABASE_SCHEMA_WRITE_INTERVAL_MS = 250;
+async function waitForDatabaseSchemaMutation(lastMutationAt) {
+    const remaining = DATABASE_SCHEMA_MUTATION_INTERVAL_MS - (Date.now() - lastMutationAt);
+    if (remaining > 0) {
+        await new Promise((resolve) => setTimeout(resolve, remaining));
+    }
+}
+async function waitForAuditedDatabaseSchemaWrite(lastWriteAt) {
+    const remaining = AUDITED_DATABASE_SCHEMA_WRITE_INTERVAL_MS - (Date.now() - lastWriteAt);
+    if (remaining > 0) {
+        await new Promise((resolve) => setTimeout(resolve, remaining));
+    }
+}
+function deletePartitionsLeafFirst(items) {
+    const itemsByKey = new Map(items.map((item) => [item.stableKey, item]));
+    const childrenByParent = new Map();
+    for (const item of itemsByKey.values()) {
+        if (!item.parentStableKey) {
+            continue;
+        }
+        const children = childrenByParent.get(item.parentStableKey) || [];
+        children.push(item);
+        childrenByParent.set(item.parentStableKey, children);
+    }
+    const ordered = [];
+    const visited = new Set();
+    const visit = (item) => {
+        const stableKey = item.stableKey;
+        if (visited.has(stableKey)) {
+            return;
+        }
+        visited.add(stableKey);
+        for (const child of (childrenByParent.get(stableKey) || []).sort((left, right) => (left.stableKey.localeCompare(right.stableKey)))) {
+            visit(child);
+        }
+        ordered.push(item);
+    };
+    for (const item of [...itemsByKey.values()].sort((left, right) => (left.stableKey.localeCompare(right.stableKey)))) {
+        visit(item);
+    }
+    return ordered;
+}
+function resolveLivePartitionDeleteTarget(input) {
+    const catalog = targetPlanCatalog(input.databases, input.stableKeyName);
+    const matches = catalog.managed.filter((entry) => entry.manifest.stableKey === input.stableKey);
+    if (matches.length !== 1) {
+        throw new Error(`expected one live target partition match, found ${matches.length}`);
+    }
+    const target = matches[0];
+    if (target.manifest.kind !== 'database-partition' || target.manifest.parentStableKey !== input.parentStableKey) {
+        throw new Error('live target partition parent relationship changed before delete');
+    }
+    if (target.hash !== input.expectedHash) {
+        throw new Error('live target partition changed after planning');
+    }
+    return target;
+}
+async function assertNoActiveDatabaseViewDependencies(input) {
+    const activeViews = await input.client.listAllDatabaseViews();
+    const dependencies = activeViews.filter((view) => (!view.deletedAt
+        && Array.isArray(view.sourceDatabaseIds)
+        && view.sourceDatabaseIds.includes(input.databaseId)));
+    if (dependencies.length > 0) {
+        throw new Error(`active Database View dependency blocks this operation (${dependencies.length} view(s))`);
+    }
+}
+async function verifyDeletedDatabaseSchema(input) {
+    try {
+        const record = unwrapData(await input.client.getDatabaseSchema(input.databaseId));
+        if (!record.deletedAt && !record.deletedBy) {
+            throw new Error('deleted partition remains active after delete');
+        }
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404) {
+            return;
+        }
+        throw error;
+    }
+}
+function resolveLiveOrphanRootDeleteTarget(input) {
+    const catalog = targetPlanCatalog(input.databases, input.stableKeyName);
+    const matches = catalog.managed.filter((entry) => entry.manifest.stableKey === input.stableKey);
+    if (matches.length !== 1) {
+        throw new Error(`expected one live target root schema match, found ${matches.length}`);
+    }
+    const target = matches[0];
+    if (target.manifest.kind !== 'database-schema') {
+        throw new Error('live target schema became a partition before delete');
+    }
+    if (target.hash !== input.expectedHash) {
+        throw new Error('live target root schema changed after planning');
+    }
+    return target;
+}
+function recordDeletedPartitionTombstone(input) {
+    const { projectRoot } = requireProjectLayout(input.cwd, 'Database Schema');
+    const lock = readComponentLock(projectRoot);
+    const existing = lock.databaseSchemas[input.stableKey];
+    if (!existing) {
+        throw new Error('cannot record tombstone without an existing Database Schema lock entry');
+    }
+    lock.databaseSchemas[input.stableKey] = {
+        ...existing,
+        environments: {
+            ...existing.environments,
+            [input.envName]: {
+                remoteHash: input.remoteHash,
+                tombstone: {
+                    deletedAt: new Date().toISOString(),
+                    parentStableKey: input.parentStableKey,
+                },
+            },
+        },
+    };
+    writeComponentLock(projectRoot, lock);
+}
+export async function pushDatabaseSchemas(input) {
+    const plan = await buildDatabaseSchemasPlan(input);
+    const localByKey = readWorkspaceDatabaseSchemasForPush(input.cwd, input.stableKeyName);
+    if (input.stableKey && !localByKey.has(input.stableKey) && input.pruneOrphans !== true) {
+        throw new Error(`Database Schema Stable Key "${input.stableKey}" was not found in the workspace.`);
+    }
+    const selected = (item) => !input.stableKey || item.stableKey === input.stableKey;
+    const results = [];
+    const lastMutation = { at: 0 };
+    let targetInventory;
+    const readTargetInventory = async () => {
+        if (!targetInventory) {
+            const listed = await input.client.listAllDatabaseSchemas({ projection: 'pull' });
+            targetInventory = listed.databases;
+        }
+        return targetInventory;
+    };
+    const replaceTargetInventoryRecord = (record) => {
+        targetInventory = replaceDatabaseSchemaRecord(targetInventory || [], record);
+    };
+    const blockedCreateStatuses = new Set([
+        'access-policy-required',
+        'manual-schema-migration-required',
+        'collision',
+    ]);
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && Boolean(candidate.stableKey)
+        && localByKey.has(candidate.stableKey || '')
+        && (blockedCreateStatuses.has(candidate.status)
+            || (candidate.status === 'missing-lock' && input.force !== true))))) {
+        const local = localByKey.get(item.stableKey || '');
+        results.push({
+            stableKey: item.stableKey,
+            action: 'skipped',
+            status: 'skipped',
+            targetPath: localTargetPath(input.cwd, local.manifestPath),
+            reason: item.status === 'manual-schema-migration-required' && input.force === true
+                ? `${item.reason || item.status}; --force cannot bypass it`
+                : item.reason || item.status,
+        });
+    }
+    const createItems = createItemsInDependencyOrder(plan.items.filter((item) => selected(item) && item.status === 'create'), localByKey);
+    const resultsByKey = new Map(results.map((result) => [result.stableKey, result]));
+    for (const item of createItems) {
+        const stableKey = item.stableKey;
+        const local = localByKey.get(stableKey);
+        if (!local) {
+            results.push({ stableKey, action: 'create', status: 'failed', targetPath: stableKey, error: 'desired manifest disappeared after planning' });
+            continue;
+        }
+        const parentResult = local.manifest.parentStableKey
+            ? resultsByKey.get(local.manifest.parentStableKey)
+            : undefined;
+        if (parentResult && parentResult.status !== 'deployed') {
+            const skipped = {
+                stableKey,
+                action: 'skipped',
+                status: 'skipped',
+                targetPath: localTargetPath(input.cwd, local.manifestPath),
+                reason: `parent "${local.manifest.parentStableKey}" was not created`,
+            };
+            results.push(skipped);
+            resultsByKey.set(stableKey, skipped);
+            continue;
+        }
+        let writeAccepted = false;
+        try {
+            const desired = portableDatabaseSchemaManifest(local.manifest);
+            if (hashPortableDatabaseSchema(desired) !== item.desiredHash) {
+                throw new Error('desired manifest changed after planning');
+            }
+            await waitForDatabaseSchemaMutation(lastMutation.at);
+            const preflight = await recheckDatabaseSchemaCreate({
+                client: input.client,
+                records: await readTargetInventory(),
+                manifest: desired,
+                stableKeyName: input.stableKeyName,
+            });
+            lastMutation.at = Date.now();
+            const created = unwrapData(await input.client.createDatabaseSchema(createPayloadForDatabaseSchema({ manifest: desired, parentName: preflight.parentName })));
+            writeAccepted = true;
+            const createdId = databaseIdOf(created);
+            if (!createdId) {
+                throw new Error('create response did not include databaseId');
+            }
+            const verified = unwrapData(await input.client.getDatabaseSchema(createdId));
+            const remoteHash = verifyCreatedDatabaseSchema({
+                created: verified,
+                recordsBeforeCreate: preflight.databases,
+                desired,
+                stableKeyName: input.stableKeyName,
+            });
+            replaceTargetInventoryRecord(verified);
+            updateDatabaseSchemaEnvironmentBaseline({
+                cwd: input.cwd,
+                envName: input.envName,
+                manifestPath: local.manifestPath,
+                manifest: desired,
+                remoteHash,
+            });
+            const deployed = {
+                stableKey,
+                action: 'create',
+                status: 'deployed',
+                targetPath: localTargetPath(input.cwd, local.manifestPath),
+            };
+            results.push(deployed);
+            resultsByKey.set(stableKey, deployed);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const unavailableParent = error instanceof PartitionParentUnavailableError;
+            const result = {
+                stableKey,
+                action: unavailableParent ? 'skipped' : 'create',
+                status: unavailableParent ? 'skipped' : writeAccepted ? 'write-unverified' : 'failed',
+                targetPath: localTargetPath(input.cwd, local.manifestPath),
+                ...(unavailableParent
+                    ? { reason: message }
+                    : writeAccepted
+                        ? { reason: `POST was accepted, but readback did not verify the desired portable hash; the environment lock was not updated (${message})` }
+                        : { error: message }),
+            };
+            results.push(result);
+            resultsByKey.set(stableKey, result);
+        }
+    }
+    const lastAuditedWrite = { at: 0 };
+    const processUpdate = async (item, action) => {
+        const stableKey = item.stableKey;
+        const local = localByKey.get(stableKey);
+        const targetPath = local ? localTargetPath(input.cwd, local.manifestPath) : stableKey;
+        let writeAccepted = false;
+        try {
+            if (!local) {
+                throw new Error('desired manifest disappeared after planning');
+            }
+            const desired = portableDatabaseSchemaManifest(local.manifest);
+            const desiredHash = hashPortableDatabaseSchema(desired);
+            if (desiredHash !== item.desiredHash) {
+                throw new Error('desired manifest changed after planning');
+            }
+            if (!item.currentHash) {
+                throw new Error('plan did not include a target portable hash');
+            }
+            let live;
+            if (action === 'update') {
+                const auditedByPlan = item.changes?.some((change) => change.kind === 'audit-trigger-rebuild') === true;
+                for (let attempt = 0; attempt < 2; attempt += 1) {
+                    try {
+                        if (auditedByPlan) {
+                            await waitForAuditedDatabaseSchemaWrite(lastAuditedWrite.at);
+                        }
+                        live = await resolveLiveDatabaseSchemaWriteTarget({
+                            client: input.client,
+                            records: await readTargetInventory(),
+                            stableKey,
+                            stableKeyName: input.stableKeyName,
+                            expectedHash: item.currentHash,
+                        });
+                        if (!auditedByPlan && live.record.audit === true && lastAuditedWrite.at > 0) {
+                            await waitForAuditedDatabaseSchemaWrite(lastAuditedWrite.at);
+                            live = await resolveLiveDatabaseSchemaWriteTarget({
+                                client: input.client,
+                                records: await readTargetInventory(),
+                                stableKey,
+                                stableKeyName: input.stableKeyName,
+                                expectedHash: item.currentHash,
+                            });
+                        }
+                        if (item.changes?.some((change) => change.kind === 'column-renamed')) {
+                            await assertNoActiveDatabaseViewDependencies({
+                                client: input.client,
+                                databaseId: live.databaseId,
+                            });
+                        }
+                        await waitForDatabaseSchemaMutation(lastMutation.at);
+                        lastMutation.at = Date.now();
+                        await input.client.updateDatabaseSchema(live.databaseId, buildDatabaseSchemaUpdatePayload({
+                            desired,
+                            target: live.record,
+                            stableKeyName: input.stableKeyName,
+                        }));
+                        writeAccepted = true;
+                        if (live.record.audit === true) {
+                            lastAuditedWrite.at = Date.now();
+                        }
+                        break;
+                    }
+                    catch (error) {
+                        if (attempt === 1 || !live || !isRetriableAuditedDatabaseSchemaWrite(error, live.record)) {
+                            throw error;
+                        }
+                        lastAuditedWrite.at = Date.now();
+                    }
+                }
+            }
+            else {
+                live = await resolveLiveDatabaseSchemaWriteTarget({
+                    client: input.client,
+                    records: await readTargetInventory(),
+                    stableKey,
+                    stableKeyName: input.stableKeyName,
+                    expectedHash: item.currentHash,
+                });
+            }
+            if (!live) {
+                throw new Error('live target Database Schema could not be resolved before verification');
+            }
+            const verified = unwrapData(await input.client.getDatabaseSchema(live.databaseId));
+            const remoteHash = verifyDatabaseSchemaWrite({
+                record: verified,
+                recordsBeforeWrite: live.records,
+                desired,
+                stableKeyName: input.stableKeyName,
+            });
+            replaceTargetInventoryRecord(verified);
+            updateDatabaseSchemaEnvironmentBaseline({
+                cwd: input.cwd,
+                envName: input.envName,
+                manifestPath: local.manifestPath,
+                manifest: desired,
+                remoteHash,
+            });
+            results.push({
+                stableKey,
+                action,
+                status: 'deployed',
+                targetPath,
+                ...(action === 'reconcile' && item.status === 'missing-lock'
+                    ? { reason: 'force-adopted verified target into environment lock baseline' }
+                    : {}),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+                stableKey,
+                action,
+                status: writeAccepted ? 'write-unverified' : 'failed',
+                targetPath,
+                ...(writeAccepted
+                    ? {
+                        reason: `PUT was accepted, but readback did not verify the desired portable hash; the environment lock was not updated (${message})`,
+                    }
+                    : { error: message }),
+            });
+        }
+    };
+    const forcedContentDrift = (item) => (input.force === true
+        && (item.status === 'missing-lock' || item.status === 'remote-changed' || item.status === 'conflict')
+        && item.desiredHash !== item.currentHash
+        && !item.changes?.some((change) => change.risk === 'manual'));
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && candidate.status === 'safe-update'))) {
+        await processUpdate(item, 'update');
+    }
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && forcedContentDrift(candidate)))) {
+        await processUpdate(item, 'update');
+    }
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && (candidate.status === 'reconciled'
+            || (input.force === true
+                && candidate.status === 'missing-lock'
+                && candidate.desiredHash === candidate.currentHash))))) {
+        await processUpdate(item, 'reconcile');
+    }
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && (candidate.status === 'missing-lock' || candidate.status === 'remote-changed' || candidate.status === 'conflict')
+        && !forcedContentDrift(candidate)
+        && !results.some((result) => result.stableKey === candidate.stableKey)))) {
+        const local = localByKey.get(item.stableKey || '');
+        if (!local) {
+            continue;
+        }
+        results.push({
+            stableKey: item.stableKey,
+            action: 'skipped',
+            status: 'skipped',
+            targetPath: localTargetPath(input.cwd, local.manifestPath),
+            reason: item.changes?.some((change) => change.risk === 'manual')
+                ? 'one or more changes require an explicit DDL or data migration; --force cannot bypass it'
+                : item.status === 'missing-lock'
+                    ? 'missing environment lock baseline; review the live target and re-run with --force to adopt an identical target or overwrite safe portable content only'
+                    : 'target content changed since the lock baseline; review it and re-run with --force to overwrite safe portable content only',
+        });
+    }
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && (candidate.status === 'previously-deleted-partition' || candidate.status === 'replacement-requires-two-phases')
+        && Boolean(candidate.stableKey)))) {
+        const stableKey = item.stableKey;
+        if (results.some((result) => result.stableKey === stableKey)) {
+            continue;
+        }
+        const local = localByKey.get(stableKey);
+        results.push({
+            stableKey,
+            action: 'skipped',
+            status: 'skipped',
+            targetPath: local ? localTargetPath(input.cwd, local.manifestPath) : stableKey,
+            reason: item.reason || item.status,
+        });
+    }
+    const deleteItems = deletePartitionsLeafFirst(plan.items.filter((candidate) => (selected(candidate)
+        && candidate.status === 'delete-partition'
+        && Boolean(candidate.stableKey)
+        && Boolean(candidate.parentStableKey)
+        && Boolean(candidate.currentHash))));
+    const deletedPartitionKeys = new Set();
+    for (const item of deleteItems) {
+        const stableKey = item.stableKey;
+        if (input.prunePartitions !== true || input.prunePartitionsConfirmed !== true || input.force !== true) {
+            results.push({
+                stableKey,
+                action: 'skipped',
+                status: 'skipped',
+                targetPath: stableKey,
+                reason: 'partition delete requires --prune-partitions --yes --force',
+            });
+            continue;
+        }
+        try {
+            const databases = await readTargetInventory();
+            const catalog = targetPlanCatalog(databases, input.stableKeyName);
+            const live = resolveLivePartitionDeleteTarget({
+                databases,
+                stableKey,
+                stableKeyName: input.stableKeyName,
+                parentStableKey: item.parentStableKey,
+                expectedHash: item.currentHash,
+            });
+            const retainedChild = catalog.managed.find((entry) => (entry.manifest.parentStableKey === stableKey
+                && !deletedPartitionKeys.has(entry.manifest.stableKey)));
+            if (retainedChild) {
+                throw new Error(`live target partition still has retained child "${retainedChild.manifest.stableKey}"`);
+            }
+            await assertNoActiveDatabaseViewDependencies({ client: input.client, databaseId: live.databaseId });
+            await waitForDatabaseSchemaMutation(lastMutation.at);
+            const refreshed = unwrapData(await input.client.getDatabaseSchema(live.databaseId));
+            replaceTargetInventoryRecord(refreshed);
+            const deleteTarget = resolveLivePartitionDeleteTarget({
+                databases: await readTargetInventory(),
+                stableKey,
+                stableKeyName: input.stableKeyName,
+                parentStableKey: item.parentStableKey,
+                expectedHash: item.currentHash,
+            });
+            const currentChildren = await input.client.findActiveDatabaseSchemasByField('parent', deleteTarget.manifest.name);
+            const retainedCurrentChild = currentChildren.find((record) => {
+                const childStableKey = configuredStableKey(record, input.stableKeyName);
+                return !childStableKey || !deletedPartitionKeys.has(childStableKey);
+            });
+            if (retainedCurrentChild) {
+                throw new Error(`live target partition still has retained child "${configuredStableKey(retainedCurrentChild, input.stableKeyName) || databaseIdOf(retainedCurrentChild)}"`);
+            }
+            lastMutation.at = Date.now();
+            await input.client.deleteDatabaseSchema(deleteTarget.databaseId);
+            await verifyDeletedDatabaseSchema({
+                client: input.client,
+                databaseId: deleteTarget.databaseId,
+            });
+            targetInventory = (await readTargetInventory()).filter((record) => (databaseIdOf(record) !== deleteTarget.databaseId));
+            recordDeletedPartitionTombstone({
+                cwd: input.cwd,
+                envName: input.envName,
+                stableKey,
+                parentStableKey: item.parentStableKey,
+                remoteHash: item.currentHash,
+            });
+            deletedPartitionKeys.add(stableKey);
+            results.push({ stableKey, action: 'delete', status: 'deployed', targetPath: stableKey });
+        }
+        catch (error) {
+            results.push({
+                stableKey,
+                action: 'delete',
+                status: 'failed',
+                targetPath: stableKey,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    for (const item of plan.items.filter((candidate) => (selected(candidate)
+        && candidate.status === 'orphan-root'
+        && Boolean(candidate.stableKey)
+        && Boolean(candidate.currentHash)))) {
+        const stableKey = item.stableKey;
+        if (input.pruneOrphans !== true || input.pruneOrphansConfirmed !== true || input.force !== true) {
+            results.push({
+                stableKey,
+                action: 'skipped',
+                status: 'skipped',
+                targetPath: stableKey,
+                reason: 'root orphan delete requires --prune-orphans --yes --force',
+            });
+            continue;
+        }
+        try {
+            const live = resolveLiveOrphanRootDeleteTarget({
+                databases: await readTargetInventory(),
+                stableKey,
+                stableKeyName: input.stableKeyName,
+                expectedHash: item.currentHash,
+            });
+            await assertNoActiveDatabaseViewDependencies({ client: input.client, databaseId: live.databaseId });
+            const activeChildren = await input.client.findActiveDatabaseSchemasByField('parent', live.manifest.name);
+            if (activeChildren.length > 0) {
+                throw new Error(`live target root schema still has ${activeChildren.length} active partition(s)`);
+            }
+            await waitForDatabaseSchemaMutation(lastMutation.at);
+            const refreshed = unwrapData(await input.client.getDatabaseSchema(live.databaseId));
+            replaceTargetInventoryRecord(refreshed);
+            const deleteTarget = resolveLiveOrphanRootDeleteTarget({
+                databases: await readTargetInventory(),
+                stableKey,
+                stableKeyName: input.stableKeyName,
+                expectedHash: item.currentHash,
+            });
+            lastMutation.at = Date.now();
+            await input.client.deleteDatabaseSchema(deleteTarget.databaseId);
+            await verifyDeletedDatabaseSchema({ client: input.client, databaseId: deleteTarget.databaseId });
+            targetInventory = (await readTargetInventory()).filter((record) => (databaseIdOf(record) !== deleteTarget.databaseId));
+            results.push({ stableKey, action: 'delete', status: 'deployed', targetPath: stableKey });
+        }
+        catch (error) {
+            results.push({
+                stableKey,
+                action: 'delete',
+                status: 'failed',
+                targetPath: stableKey,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { plan, results };
+}