@abloatai/transaction 0.58.0 → 0.59.0

package/dist/schema/deployment/sequence.js

@@ -0,0 +1,71 @@
+const PHASES = [
+    'intent',
+    'expand',
+    'dual_write',
+    'backfill',
+    'verify',
+    'switch',
+    'contract',
+    'recover',
+];
+function statusOf(findings) {
+    if (findings.some(({ severity }) => severity === 'blocker' || severity === 'error')) {
+        return 'blocked';
+    }
+    if (findings.some(({ code }) => code === 'lifecycle_ready'))
+        return 'ready';
+    return findings.every(({ severity }) => severity === 'warning' || severity === 'info')
+        ? 'advisory'
+        : 'ready';
+}
+function manifestStep(finding) {
+    const status = statusOf([finding]);
+    return {
+        id: finding.id,
+        phase: finding.phase,
+        owner: finding.owner,
+        title: finding.message,
+        action: finding.action,
+        dependsOn: finding.dependsOn ?? [],
+        findingIds: [finding.id],
+        status,
+        executableByAblo: finding.owner === 'ablo' && status === 'ready',
+    };
+}
+function groupedStep(phase, owner, findings) {
+    const status = statusOf(findings);
+    return {
+        id: `${phase}:${owner}`,
+        phase,
+        owner,
+        title: `${phase} — ${owner.replaceAll('_', ' ')}`,
+        action: [...new Set(findings.map(({ action }) => action))].join(' '),
+        dependsOn: [],
+        findingIds: findings.map(({ id }) => id),
+        status,
+        executableByAblo: owner === 'ablo' && status === 'ready',
+    };
+}
+/** Preserve manifest gates while grouping ordinary diagnostics by phase/owner. */
+export function sequenceDeployment(findings) {
+    const steps = [];
+    let previousPhase = [];
+    for (const phase of PHASES) {
+        const phaseFindings = findings.filter((finding) => finding.phase === phase);
+        const manifest = phaseFindings.filter(({ id }) => id.startsWith('manifest:'));
+        const ordinary = phaseFindings.filter(({ id }) => !id.startsWith('manifest:'));
+        const phaseSteps = manifest.map(manifestStep);
+        for (const owner of [...new Set(ordinary.map(({ owner }) => owner))]) {
+            phaseSteps.push(groupedStep(phase, owner, ordinary.filter((finding) => finding.owner === owner)));
+        }
+        for (const step of phaseSteps) {
+            const explicit = step.dependsOn;
+            const barrier = explicit.length === 0 ? previousPhase : [];
+            steps.push({ ...step, dependsOn: [...new Set([...explicit, ...barrier])] });
+        }
+        if (phaseSteps.length > 0)
+            previousPhase = phaseSteps.map(({ id }) => id);
+    }
+    return steps;
+}
+//# sourceMappingURL=sequence.js.map

package/dist/schema/deployment/sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.js","sourceRoot":"","sources":["../../../src/schema/deployment/sequence.ts"],"names":[],"mappings":"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"}

package/dist/schema/index.d.ts

@@ -38,6 +38,7 @@ export { selectModels, omitModels, omittedModelError } from './select.js';
 export { generateProvisionPlan, generateMigrationPlan, appSchemaName, camelToSnake, snakeToCamel, q, sqlType, type ProvisionPlan, type MigrationPlan, } from './ddl.js';
 export { PG_LOCK_NOT_AVAILABLE, resolveDdlLockTimeout, resolveDdlMaxLockAttempts, ddlLockRetryBackoffMs, type DdlLockEnv, } from './ddlLock.js';
 export { diffSchema, classifyMigration, classifyCast, isAutoApplicable, isBlockerResolved, unresolvedBlockers, type BackfillValue, type MigrationStep, type FieldChanges, type FieldColumnChange, type FieldTypeChange, type NullabilityChange, type EnumValuesChange, type IndexChange, type CastSafety, type FieldType, type RenameHints, type MigrationSignal, type MigrationClassification, type WarningCode, type BlockerCode, } from './diff.js';
+export * from './deployment/index.js';
 export { generateTypes } from './generate.js';
 export { query, defineQueries, type QueryDef, type QueryRecord, type Queries, type InferQueryInput, type InferQueryResult, } from './queries.js';
 export { abloOpenApi, schemaToOpenApi, type SchemaToOpenApiOptions } from './openapi.js';

package/dist/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}

package/dist/schema/index.js

@@ -68,6 +68,10 @@ export { generateProvisionPlan, generateMigrationPlan, appSchemaName, camelToSna
 export { PG_LOCK_NOT_AVAILABLE, resolveDdlLockTimeout, resolveDdlMaxLockAttempts, ddlLockRetryBackoffMs, } from './ddlLock.js';
 // Schema diff + migration planning — produces the plan the DDL layer turns into SQL.
 export { diffSchema, classifyMigration, classifyCast, isAutoApplicable, isBlockerResolved, unresolvedBlockers, } from './diff.js';
+// One source/active/database deployment skeleton. CLI check/plan/push/migrate,
+// server activation, and runtime drift project this contract instead of
+// maintaining lateral planners.
+export * from './deployment/index.js';
 // Schema → TypeScript type emission.
 export { generateTypes } from './generate.js';
 // Query definition DSL + type inference

package/dist/schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/transaction",
-  "version": "0.58.0",
+  "version": "0.59.0",
   "description": "The headless Ablo transaction client and canonical contracts for reads, commits, confirmation, claims, and durable observation.",
   "license": "Apache-2.0",
   "type": "module",

package/src/client/ablo.ts

@@ -23,9 +23,9 @@
 import {
   createAbloHttpClient,
   type AbloHttpClient,
-  type AbloHttpClientOptions,
 } from '../transport/http/client.js';
 import type { SchemaRecord } from '../schema/schema.js';
+import type { PublicAbloOptions } from './surface.js';
 import type * as _Streams from '../types/streams.js';
 import type * as _SchemaTypes from '../schema/schema.js';
 import type * as _Global from '../types/global.js';
@@ -40,7 +40,7 @@ import type * as _Http from './resources/httpResources.js';
  * socket carve lands (ADR 0016, follow-up 3a).
  */
 export function Ablo<const S extends SchemaRecord>(
-  options: AbloHttpClientOptions<S> & { transport?: 'http' },
+  options: PublicAbloOptions<S>,
 ): AbloHttpClient<S> {
   return createAbloHttpClient(options);
 }

package/src/client/surface.ts

@@ -0,0 +1,50 @@
+/**
+ * Machine-checked names on the public `Ablo({ ... })` configuration surface.
+ *
+ * Documentation reads this tuple. Type equality below makes a constructor
+ * option change fail compilation until the reference inventory changes with it.
+ * `onCommitReceipt` is an internal transport callback, so it is deliberately
+ * removed from the public factory type before the equality check.
+ */
+
+import type { AbloHttpClientOptions } from '../transport/http/client.js';
+import type { SchemaRecord } from '../schema/schema.js';
+
+export type PublicAbloOptions<S extends SchemaRecord = SchemaRecord> = Omit<
+  AbloHttpClientOptions<S>,
+  'onCommitReceipt' | 'transport'
+> & {
+  readonly transport?: 'http';
+};
+
+export const PUBLIC_ABLO_OPTION_KEYS = [
+  'schema',
+  'apiKey',
+  'authEndpoint',
+  'authToken',
+  'baseURL',
+  'dangerouslyAllowBrowser',
+  'fetch',
+  'authTimeoutMs',
+  'allowCrossOriginAuthEndpoint',
+  'bootstrapBaseUrl',
+  'defaultHeaders',
+  'defaultQuery',
+  'observability',
+  'durableWrites',
+  'commitOutbox',
+  'commitOutboxScope',
+  'transport',
+  'timeoutMs',
+] as const;
+
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+    ? true
+    : false;
+type Expect<T extends true> = T;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _PublicAbloOptionsExact = Expect<
+  Equal<(typeof PUBLIC_ABLO_OPTION_KEYS)[number], keyof PublicAbloOptions & string>
+>;

package/src/pricing.ts

@@ -46,7 +46,7 @@ export type { MeterEvent, PlanTier, RateBracket };
  * could observe the difference. It is emitted into the generated pricing
  * documentation so a stale copy is identifiable on sight.
  */
-export const PRICING_VERSION = '2026-08-24';
+export const PRICING_VERSION = '2026-08-28';
 
 /**
  * Resolve a stored plan string (`stripe_subscription.plan`) to a tier.
@@ -257,7 +257,7 @@ export const PLANS = z
       hardCapOps: null,
       hardCapOpsPerDay: null,
       storageGib: 50,
-      maxConcurrentConnections: 1_000,
+      maxConcurrentConnections: 5_000,
       contractPriced: false,
       features: ['auditExport'],
     },
@@ -397,3 +397,17 @@ export function dailyOpsCapForTier(tier: PlanTier): number | null {
 export function connectionCapForTier(tier: PlanTier): number | null {
   return PLANS[tier].maxConcurrentConnections;
 }
+
+/**
+ * The first public tier that can reserve the requested connection capacity.
+ * A `null` cap is negotiated capacity, not infinity in the runtime; it is the
+ * commercial catch-all that sends the buyer into an Enterprise capacity plan.
+ */
+export function selectPlanForConnectionCapacity(connections: number): PlanTier {
+  const requested = Number.isFinite(connections) ? Math.max(1, Math.ceil(connections)) : 1;
+  for (const tier of PLAN_ORDER) {
+    const cap = PLANS[tier].maxConcurrentConnections;
+    if (cap === null || requested <= cap) return tier;
+  }
+  return 'enterprise';
+}

package/src/schema/ddl.ts

@@ -318,7 +318,9 @@ export function generateProvisionPlan(
     for (const [fieldName, meta] of Object.entries(model.fields)) {
       const col = meta.column ?? camelToSnake(fieldName);
       if (BASE_COLUMNS.has(col) || col === orgCol) continue;
-      statements.push(`ALTER TABLE ${qt} ADD COLUMN IF NOT EXISTS ${q(col)} ${sqlType(meta.type)};`);
+      statements.push(
+        `ALTER TABLE ${qt} ADD COLUMN IF NOT EXISTS ${q(col)} ${sqlType(meta.type)}${meta.isOptional ? '' : ' NOT NULL'};`,
+      );
       if (meta.type === 'enum' && meta.enumValues && meta.enumValues.length > 0) {
         const cname = `${table}_${col}_enum`;
         const allowed = meta.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(', ');

package/src/schema/deployment/backfill.ts

@@ -0,0 +1,88 @@
+export type BackfillStatus = 'pending' | 'running' | 'paused' | 'succeeded' | 'failed' | 'cancelled';
+
+export interface BackfillCheckpoint {
+  readonly jobId: string;
+  readonly idempotencyKey: string;
+  readonly cursor: string | null;
+  readonly processed: number;
+  readonly batches: number;
+  readonly status: BackfillStatus;
+  readonly updatedAt: string;
+  readonly error?: string;
+}
+
+export interface BackfillBatchResult {
+  readonly nextCursor: string | null;
+  readonly processed: number;
+  readonly done: boolean;
+}
+
+export interface ResumableBackfillEffects {
+  readonly load: (jobId: string) => Promise<BackfillCheckpoint | null>;
+  readonly save: (checkpoint: BackfillCheckpoint) => Promise<void>;
+  /** Must be idempotent for the job idempotency key and input cursor. */
+  readonly runBatch: (input: { jobId: string; idempotencyKey: string; cursor: string | null; limit: number; signal?: AbortSignal }) => Promise<BackfillBatchResult>;
+  readonly now?: () => string;
+  readonly retry?: (error: unknown, attempt: number) => Promise<void>;
+  /** Operational throttle checked before each batch; pause preserves the checkpoint for an exact resume. */
+  readonly beforeBatch?: (checkpoint: BackfillCheckpoint) => Promise<'run' | 'pause'>;
+  readonly onProgress?: (checkpoint: BackfillCheckpoint) => Promise<void> | void;
+}
+
+export interface ResumableBackfillOptions {
+  readonly jobId: string;
+  readonly idempotencyKey: string;
+  readonly batchSize?: number;
+  readonly maxBatches?: number;
+  readonly maxAttempts?: number;
+  readonly signal?: AbortSignal;
+}
+
+/** Bounded, resumable runner. A durable effect owns checkpoints; the transform owns idempotency. */
+export async function runResumableBackfill(effects: ResumableBackfillEffects, options: ResumableBackfillOptions): Promise<BackfillCheckpoint> {
+  if (!options.jobId || !options.idempotencyKey) throw new Error('backfill jobId and idempotencyKey are required');
+  const batchSize = options.batchSize ?? 500;
+  const maxBatches = options.maxBatches ?? 100;
+  const maxAttempts = options.maxAttempts ?? 3;
+  if (batchSize < 1 || maxBatches < 1 || maxAttempts < 1) throw new Error('backfill bounds must be positive');
+  const now = effects.now ?? (() => new Date().toISOString());
+  let checkpoint = await effects.load(options.jobId) ?? { jobId: options.jobId, idempotencyKey: options.idempotencyKey, cursor: null, processed: 0, batches: 0, status: 'pending' as const, updatedAt: now() };
+  if (checkpoint.idempotencyKey !== options.idempotencyKey) throw new Error(`backfill job ${options.jobId} was created with a different idempotency key`);
+  if (checkpoint.status === 'succeeded') return checkpoint;
+  for (let batch = 0; batch < maxBatches; batch++) {
+    if (options.signal?.aborted) {
+      checkpoint = { ...checkpoint, status: 'cancelled', updatedAt: now() };
+      await effects.save(checkpoint);
+      return checkpoint;
+    }
+    if (await effects.beforeBatch?.(checkpoint) === 'pause') {
+      checkpoint = { ...checkpoint, status: 'paused', updatedAt: now() };
+      await effects.save(checkpoint);
+      await effects.onProgress?.(checkpoint);
+      return checkpoint;
+    }
+    let result: BackfillBatchResult | undefined;
+    let lastError: unknown;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        result = await effects.runBatch({ jobId: options.jobId, idempotencyKey: options.idempotencyKey, cursor: checkpoint.cursor, limit: batchSize, ...(options.signal ? { signal: options.signal } : {}) });
+        break;
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxAttempts) await effects.retry?.(error, attempt);
+      }
+    }
+    if (!result) {
+      checkpoint = { ...checkpoint, status: 'failed', updatedAt: now(), error: lastError instanceof Error ? lastError.message : String(lastError) };
+      await effects.save(checkpoint);
+      await effects.onProgress?.(checkpoint);
+      return checkpoint;
+    }
+    if (!result.done && result.nextCursor === checkpoint.cursor) throw new Error(`backfill job ${options.jobId} did not advance its cursor`);
+    checkpoint = { jobId: checkpoint.jobId, idempotencyKey: checkpoint.idempotencyKey, cursor: result.nextCursor, processed: checkpoint.processed + result.processed, batches: checkpoint.batches + 1, status: result.done ? 'succeeded' : 'running', updatedAt: now() };
+    await effects.save(checkpoint);
+    await effects.onProgress?.(checkpoint);
+    if (result.done) return checkpoint;
+  }
+  return checkpoint;
+}

package/src/schema/deployment/contracts.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import type { SchemaJSON } from '../serialize.js';
+import type { BackfillValue, RenameHints } from '../diff.js';
+import type { MigrationStep } from '../diff.js';
+
+export const deploymentPhaseSchema = z.enum(['intent', 'expand', 'dual_write', 'backfill', 'verify', 'switch', 'contract', 'recover']);
+export type DeploymentPhase = z.infer<typeof deploymentPhaseSchema>;
+export const deploymentOwnerSchema = z.enum(['application', 'application_migration', 'ablo']);
+export type DeploymentOwner = z.infer<typeof deploymentOwnerSchema>;
+export const deploymentSeveritySchema = z.enum(['blocker', 'error', 'warning', 'info']);
+export type DeploymentSeverity = z.infer<typeof deploymentSeveritySchema>;
+export const deploymentCategorySchema = z.enum(['policy_intent', 'physical_contract', 'compatibility', 'data_movement', 'destructive_contract', 'advisory', 'observation']);
+export type DeploymentCategory = z.infer<typeof deploymentCategorySchema>;
+export const deploymentDirectionSchema = z.enum(['source_to_active', 'source_to_database', 'active_to_database', 'client_to_active']);
+export type DeploymentDirection = z.infer<typeof deploymentDirectionSchema>;
+
+export const databaseColumnSnapshotSchema = z.object({
+  name: z.string(), dataType: z.string(), nullable: z.boolean(), default: z.string().nullable(), primary: z.boolean(), unique: z.boolean(),
+  /** Capped count of rows whose required routing value is NULL; absent for ordinary columns. */
+  nullCount: z.number().int().nonnegative().nullable().optional(),
+});
+export type DatabaseColumnSnapshot = z.infer<typeof databaseColumnSnapshotSchema>;
+export const databaseIndexSnapshotSchema = z.object({
+  name: z.string(), columns: z.array(z.string()), unique: z.boolean(), valid: z.boolean(), ready: z.boolean(), predicate: z.string().nullable(),
+});
+export const databaseForeignKeySnapshotSchema = z.object({
+  name: z.string(), columns: z.array(z.string()), referencedSchema: z.string(), referencedTable: z.string(), referencedColumns: z.array(z.string()), validated: z.boolean(),
+});
+export const databaseTableSnapshotSchema = z.object({
+  schema: z.string(), name: z.string(), columns: z.record(z.string(), databaseColumnSnapshotSchema),
+  indexes: z.array(databaseIndexSnapshotSchema).optional(), foreignKeys: z.array(databaseForeignKeySnapshotSchema).optional(),
+  rowLevelSecurity: z.boolean().nullable(), forceRowLevelSecurity: z.boolean().nullable(),
+  replicaIdentity: z.string().nullable(), publicationMember: z.boolean().nullable(),
+});
+export type DatabaseTableSnapshot = z.infer<typeof databaseTableSnapshotSchema>;
+export const databaseSnapshotSchema = z.object({
+  observedAt: z.string(), subject: z.string(), fingerprint: z.string(), appSchema: z.string(), ownership: z.enum(['application', 'ablo']),
+  tables: z.record(z.string(), databaseTableSnapshotSchema),
+});
+export type DatabaseSnapshot = z.infer<typeof databaseSnapshotSchema>;
+
+export interface SourceSchemaSnapshot { readonly observedAt: string; readonly path: string; readonly hash: string; readonly schema: SchemaJSON; }
+export interface ActiveSchemaSnapshot { readonly observedAt: string; readonly schemaId: string; readonly version: number; readonly hash: string; readonly pushedAt: string | null; readonly schema: SchemaJSON; }
+export interface DeploymentTarget { readonly organizationId: string | null; readonly projectId: string | null; readonly branchId: string | null; readonly databaseSubject: string | null; readonly confirmed: boolean; }
+export const deploymentGateSchema = z.object({
+  id: z.string().min(1),
+  phase: z.enum(['expand', 'dual_write', 'backfill', 'verify', 'switch', 'contract']),
+  owner: deploymentOwnerSchema,
+  resource: z.string().min(1),
+  title: z.string().min(1),
+  action: z.string().min(1),
+  status: z.enum(['pending', 'ready', 'satisfied']),
+  dependsOn: z.array(z.string()).default([]),
+  approval: z.string().min(1).optional(),
+});
+export const deploymentManifestSchema = z.object({
+  id: z.string().min(1),
+  live: z.boolean().default(true),
+  targetPhase: z.enum(['expand', 'dual_write', 'backfill', 'verify', 'switch', 'contract']).default('expand'),
+  gates: z.array(deploymentGateSchema),
+});
+export type DeploymentGate = z.infer<typeof deploymentGateSchema>;
+export type DeploymentManifest = z.infer<typeof deploymentManifestSchema>;
+export interface DeploymentIntent { readonly renames?: RenameHints; readonly backfills?: readonly BackfillValue[]; readonly acceptDestructive?: boolean; readonly manifest?: DeploymentManifest; }
+export interface DeploymentObservation { readonly target: DeploymentTarget; readonly source: SourceSchemaSnapshot; readonly active: ActiveSchemaSnapshot | null; readonly database: DatabaseSnapshot | null; readonly intent?: DeploymentIntent; readonly supplementalFindings?: readonly DeploymentFinding[]; }
+
+export interface DeploymentFinding {
+  readonly id: string; readonly code: string; readonly category: DeploymentCategory; readonly severity: DeploymentSeverity;
+  readonly direction: DeploymentDirection; readonly phase: DeploymentPhase; readonly owner: DeploymentOwner;
+  readonly model?: string; readonly field?: string; readonly column?: string; readonly from?: unknown; readonly to?: unknown;
+  readonly message: string; readonly action: string;
+  readonly dependsOn?: readonly string[];
+}
+export interface DeploymentStep {
+  readonly id: string; readonly phase: DeploymentPhase; readonly owner: DeploymentOwner; readonly title: string; readonly action: string;
+  readonly dependsOn: readonly string[]; readonly findingIds: readonly string[]; readonly status: 'ready' | 'blocked' | 'advisory'; readonly executableByAblo: boolean;
+}
+export interface SchemaDeploymentPlan {
+  readonly id: 'ablo-schema-deployment-plan-v1'; readonly mode: 'plan'; readonly createdAt: string; readonly fingerprint: string; readonly target: DeploymentTarget;
+  readonly states: { readonly source: Omit<SourceSchemaSnapshot, 'schema'>; readonly active: Omit<ActiveSchemaSnapshot, 'schema'> | null; readonly database: Omit<DatabaseSnapshot, 'tables'> | null; };
+  readonly findings: readonly DeploymentFinding[]; readonly steps: readonly DeploymentStep[]; readonly outcome: 'aligned' | 'ready' | 'blocked';
+  readonly operations: { readonly sourceToActive: readonly MigrationStep[]; readonly provision: readonly MigrationStep[] };
+  readonly rollbackTarget: { readonly schemaId: string; readonly version: number; readonly hash: string; readonly strategy: 'reactivate_artifact'; } | null;
+  readonly recovery: 'rollback' | 'forward_only';
+}
+export interface DeploymentApplyResult { readonly plan: SchemaDeploymentPlan; readonly appliedStepIds: readonly string[]; readonly verification: SchemaDeploymentPlan; readonly recorded: boolean; }
+
+export const deploymentTargetSchema = z.object({
+  organizationId: z.string().nullable(), projectId: z.string().nullable(), branchId: z.string().nullable(), databaseSubject: z.string().nullable(), confirmed: z.boolean(),
+});
+export const deploymentFindingSchema = z.object({
+  id: z.string(), code: z.string(), category: deploymentCategorySchema, severity: deploymentSeveritySchema,
+  direction: deploymentDirectionSchema, phase: deploymentPhaseSchema, owner: deploymentOwnerSchema,
+  model: z.string().optional(), field: z.string().optional(), column: z.string().optional(), from: z.unknown().optional(), to: z.unknown().optional(),
+  message: z.string(), action: z.string(),
+  dependsOn: z.array(z.string()).readonly().optional(),
+});
+export const deploymentStepSchema = z.object({
+  id: z.string(), phase: deploymentPhaseSchema, owner: deploymentOwnerSchema, title: z.string(), action: z.string(),
+  dependsOn: z.array(z.string()).readonly(), findingIds: z.array(z.string()).readonly(), status: z.enum(['ready', 'blocked', 'advisory']), executableByAblo: z.boolean(),
+});
+export const schemaDeploymentPlanSchema = z.object({
+  id: z.literal('ablo-schema-deployment-plan-v1'), mode: z.literal('plan'), createdAt: z.string(), fingerprint: z.string(), target: deploymentTargetSchema,
+  states: z.object({
+    source: z.object({ observedAt: z.string(), path: z.string(), hash: z.string() }),
+    active: z.object({ observedAt: z.string(), schemaId: z.string(), version: z.number(), hash: z.string(), pushedAt: z.string().nullable() }).nullable(),
+    database: z.object({ observedAt: z.string(), subject: z.string(), fingerprint: z.string(), appSchema: z.string(), ownership: z.enum(['application', 'ablo']) }).nullable(),
+  }),
+  findings: z.array(deploymentFindingSchema).readonly(), steps: z.array(deploymentStepSchema).readonly(), outcome: z.enum(['aligned', 'ready', 'blocked']),
+  // Submitted operations are never executed. Apply re-observes and returns a
+  // server-built plan; this field is retained only to validate the full plan
+  // envelope and obtain its fingerprint.
+  operations: z.object({
+    sourceToActive: z.array(z.custom<MigrationStep>()).readonly(),
+    provision: z.array(z.custom<MigrationStep>()).readonly(),
+  }),
+  rollbackTarget: z.object({ schemaId: z.string(), version: z.number(), hash: z.string(), strategy: z.literal('reactivate_artifact') }).nullable(),
+  recovery: z.enum(['rollback', 'forward_only']),
+});

package/src/schema/deployment/fingerprint.ts

@@ -0,0 +1,13 @@
+function canonical(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(',')}}`;
+  return JSON.stringify(value);
+}
+
+/** Stable non-cryptographic identity used only to detect a changed reviewed plan. */
+export function deploymentFingerprint(value: unknown): string {
+  const input = canonical(value);
+  let hash = 0xcbf29ce484222325n;
+  for (let index = 0; index < input.length; index++) { hash ^= BigInt(input.charCodeAt(index)); hash = BigInt.asUintN(64, hash * 0x100000001b3n); }
+  return `plan_${hash.toString(16).padStart(16, '0')}`;
+}

package/src/schema/deployment/index.ts

@@ -0,0 +1,81 @@
+import type { DeploymentApplyResult, DeploymentObservation, DeploymentStep, SchemaDeploymentPlan } from './contracts.js';
+import { deploymentFingerprint } from './fingerprint.js';
+import { reconcileDeploymentManifest, reconcilePolicyIntent, reconcileSchemaToDatabase, reconcileSourceToActiveResult } from './reconcile.js';
+import { sequenceDeployment } from './sequence.js';
+
+export * from './contracts.js';
+export { deploymentFingerprint } from './fingerprint.js';
+export { reconcileClientToActive, reconcileDeploymentManifest, reconcilePolicyIntent, reconcileSchemaToDatabase, reconcileSourceToActive, reconcileSourceToActiveResult } from './reconcile.js';
+export { sequenceDeployment } from './sequence.js';
+export * from './backfill.js';
+export * from './postgresCatalog.js';
+
+function planStates(observation: DeploymentObservation): SchemaDeploymentPlan['states'] {
+  const { schema: _sourceSchema, ...source } = observation.source;
+  const active = observation.active ? (({ schema: _activeSchema, ...state }) => state)(observation.active) : null;
+  const database = observation.database ? (({ tables: _tables, ...state }) => state)(observation.database) : null;
+  return { source, active, database };
+}
+
+/** The one pure reconciliation skeleton every lifecycle surface projects. */
+export function buildSchemaDeploymentPlan(observation: DeploymentObservation, now = new Date().toISOString()): SchemaDeploymentPlan {
+  const sourceToActive = reconcileSourceToActiveResult(
+    observation.active?.schema ?? null,
+    observation.source.schema,
+    observation.intent?.renames,
+    observation.intent?.backfills,
+  );
+  const provision = reconcileSourceToActiveResult(null, observation.source.schema).operations;
+  const findings = [
+    ...reconcilePolicyIntent(observation.source.schema),
+    ...reconcileDeploymentManifest(observation.intent?.manifest),
+    ...sourceToActive.findings,
+    ...reconcileSchemaToDatabase(observation.source.schema, observation.database, 'source_to_database'),
+    ...(observation.active ? reconcileSchemaToDatabase(observation.active.schema, observation.database, 'active_to_database') : []),
+    ...(observation.supplementalFindings ?? []),
+  ];
+  const unique = [...new Map(findings.map((finding) => [finding.id, finding])).values()].map((finding) =>
+    observation.intent?.acceptDestructive && finding.category === 'destructive_contract' &&
+      finding.code !== 'mixed_expand_contract' && finding.code !== 'contract_approval_required' && finding.code !== 'lifecycle_dependency_unsatisfied'
+      ? { ...finding, severity: 'warning' as const, action: `${finding.action} Destructive intent was explicitly accepted for this reviewed plan.` }
+      : finding
+  );
+  const steps = sequenceDeployment(unique);
+  const blocking = unique.some(({ severity }) => severity === 'blocker' || severity === 'error');
+  const meaningful = unique.some(({ category }) => category !== 'advisory');
+  const states = planStates(observation);
+  const destructive = unique.some(({ category }) => category === 'destructive_contract');
+  const rollbackTarget = observation.active && !destructive ? { schemaId: observation.active.schemaId, version: observation.active.version, hash: observation.active.hash, strategy: 'reactivate_artifact' as const } : null;
+  const fingerprint = deploymentFingerprint({
+    target: observation.target,
+    states: {
+      source: { hash: states.source.hash },
+      active: states.active ? { schemaId: states.active.schemaId, version: states.active.version, hash: states.active.hash } : null,
+      database: states.database ? { subject: states.database.subject, fingerprint: states.database.fingerprint, ownership: states.database.ownership } : null,
+    },
+    intent: observation.intent ?? {}, findings: unique, steps, operations: { sourceToActive: sourceToActive.operations, provision },
+  });
+  return { id: 'ablo-schema-deployment-plan-v1', mode: 'plan', createdAt: now, fingerprint, target: observation.target, states, findings: unique, steps, operations: { sourceToActive: sourceToActive.operations, provision }, outcome: blocking ? 'blocked' : meaningful ? 'ready' : 'aligned', rollbackTarget, recovery: rollbackTarget ? 'rollback' : 'forward_only' };
+}
+
+export interface SchemaDeploymentLifecycleEffects {
+  readonly observe: () => Promise<DeploymentObservation>;
+  readonly approve?: (plan: SchemaDeploymentPlan) => Promise<boolean>;
+  readonly apply?: (step: DeploymentStep, plan: SchemaDeploymentPlan) => Promise<void>;
+  readonly record?: (result: Omit<DeploymentApplyResult, 'recorded'>) => Promise<void>;
+}
+
+/** One observe → reconcile → sequence → approve → apply → verify → record path. */
+export async function runSchemaDeploymentLifecycle(effects: SchemaDeploymentLifecycleEffects, mode: 'plan' | 'apply' = 'plan'): Promise<SchemaDeploymentPlan | DeploymentApplyResult> {
+  const plan = buildSchemaDeploymentPlan(await effects.observe());
+  if (mode === 'plan') return plan;
+  if (plan.outcome === 'blocked') throw new Error(`schema deployment plan ${plan.fingerprint} is blocked`);
+  if (!effects.apply) throw new Error('schema deployment apply effect is not configured');
+  if (effects.approve && !(await effects.approve(plan))) throw new Error('schema deployment was not approved');
+  const appliedStepIds: string[] = [];
+  for (const step of plan.steps) if (step.executableByAblo && step.status === 'ready') { await effects.apply(step, plan); appliedStepIds.push(step.id); }
+  const verification = buildSchemaDeploymentPlan(await effects.observe());
+  const unrecorded = { plan, appliedStepIds, verification };
+  await effects.record?.(unrecorded);
+  return { ...unrecorded, recorded: effects.record !== undefined };
+}