@fabrika/provider-zerops 0.8.1 → 0.9.0-cloudflare.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fabrika/provider-zerops",
-	"version": "0.8.1",
+	"version": "0.9.0-cloudflare.1",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -12,27 +12,28 @@
 	},
 	"files": [
 		"src",
-		"!src/**/__tests__/**"
+		"!src/**/__tests__/**",
+		"types"
 	],
 	"exports": {
 		".": {
 			"bun": "./src/index.ts",
-			"types": "./src/index.ts",
+			"types": "./types/src/index.d.ts",
 			"default": "./src/index.ts"
 		},
 		"./cli": {
 			"bun": "./src/cli.ts",
-			"types": "./src/cli.ts",
+			"types": "./types/src/cli.d.ts",
 			"default": "./src/cli.ts"
 		},
 		"./installation": {
 			"bun": "./src/installation/index.ts",
-			"types": "./src/installation/index.ts",
+			"types": "./types/src/installation/index.d.ts",
 			"default": "./src/installation/index.ts"
 		},
 		"./installation/topology": {
 			"bun": "./src/installation/topology/index.ts",
-			"types": "./src/installation/topology/index.ts",
+			"types": "./types/src/installation/topology/index.d.ts",
 			"default": "./src/installation/topology/index.ts"
 		}
 	},
@@ -43,14 +44,15 @@
 	},
 	"dependencies": {
 		"zod": "^3.25.76",
-		"@fabrika/auth": "0.8.1",
-		"@fabrika/auth-core": "0.8.1",
-		"@fabrika/email": "0.8.1",
-		"@fabrika/iam-contract": "0.8.1",
-		"@fabrika/installation-init": "0.8.1",
-		"@fabrika/operations-contract": "0.8.1",
-		"@fabrika/provider-contract": "0.8.1",
-		"@fabrika/proxy-core": "0.8.1",
+		"@fabrika/app": "0.9.0-cloudflare.1",
+		"@fabrika/auth": "0.9.0-cloudflare.1",
+		"@fabrika/auth-core": "0.9.0-cloudflare.1",
+		"@fabrika/email": "0.9.0-cloudflare.1",
+		"@fabrika/iam-contract": "0.9.0-cloudflare.1",
+		"@fabrika/installation-init": "0.9.0-cloudflare.1",
+		"@fabrika/operations-contract": "0.9.0-cloudflare.1",
+		"@fabrika/provider-contract": "0.9.0-cloudflare.1",
+		"@fabrika/proxy-core": "0.9.0-cloudflare.1",
 		"yaml": "^2.9.1"
 	}
 }

package/src/api/client.ts

@@ -5,6 +5,7 @@ import { waitForProcess } from './polling'
 import {
 	appVersionListSchema,
 	appVersionSchema,
+	backupConfigSchema,
 	importResultSchema,
 	integrationTokenSchema,
 	logAccessSchema,
@@ -346,6 +347,12 @@ export const createZeropsApi = (options: ZeropsApiOptions): ZeropsApi => {
 			await request('enable subdomain access', 'PUT', `/service-stack/${serviceId}/enable-subdomain-access`, { signal })
 		},
 
+		startService: async ({ serviceId, signal }) =>
+			readResponse('start service', processSchema, await request('start service', 'PUT', `/service-stack/${serviceId}/start`, { signal })),
+
+		stopService: async ({ serviceId, signal }) =>
+			readResponse('stop service', processSchema, await request('stop service', 'PUT', `/service-stack/${serviceId}/stop`, { signal })),
+
 		configureAutoscaling: async ({ serviceId, autoscalingProfileId, signal }) => {
 			const payload = await request('configure autoscaling', 'PUT', `/service-stack/${serviceId}/autoscaling`, {
 				body: { autoscalingProfileId },
@@ -364,6 +371,17 @@ export const createZeropsApi = (options: ZeropsApiOptions): ZeropsApi => {
 			return readResponse('configure custom autoscaling', processNilSchema, payload).process ?? null
 		},
 
+		getBackupConfig: async ({ serviceId, signal }) =>
+			readResponse('list backups', backupConfigSchema, await request('list backups', 'GET', `/service-stack/${serviceId}/backup`, { signal })),
+
+		configureBackup: async ({ serviceId, backupPeriod, retentionPolicy, signal }) => {
+			const payload = await request('configure backup', 'PUT', `/service-stack/${serviceId}/backup-config`, {
+				body: { backupPeriod, retentionPolicy },
+				signal,
+			})
+			return readResponse('configure backup', processNilSchema, payload).process ?? null
+		},
+
 		getService: async ({ serviceId, signal }) =>
 			readResponse('get service', serviceSchema, await request('get service', 'GET', `/service-stack/${serviceId}`, { signal })),
 

package/src/api/readers.ts

@@ -3,6 +3,8 @@ import { withoutSensitiveContent } from './service-env-response'
 import type {
 	ZeropsAppVersion,
 	ZeropsAppVersionStatus,
+	ZeropsBackupConfig,
+	ZeropsBackupRetentionPolicy,
 	ZeropsImportResult,
 	ZeropsIntegrationToken,
 	ZeropsLogAccess,
@@ -170,6 +172,33 @@ export const serviceSchema = z.object({
 	currentAutoscaling: optional(serviceAutoscalingSchema),
 }).transform(({ activeAppVersion, ...service }): ZeropsService => ({ ...service, activeAppVersionId: activeAppVersion?.id }))
 
+const backupCountSchema = z.number().int().nonnegative()
+
+/** Strict like the custom autoscaling, for the same reason: it is sent back whole, so no field may read as absent. */
+const backupRetentionPolicySchema = z.object({
+	maxTotalFiles: backupCountSchema,
+	maxTotalGiB: backupCountSchema,
+	// A Go API may serialise an empty list as null; read as the empty list it is.
+	protectedTags: z.array(z.string()).nullable().transform((tags) => tags ?? []),
+	minDaily: backupCountSchema,
+	maxDaily: backupCountSchema,
+	minWeekly: backupCountSchema,
+	maxWeekly: backupCountSchema,
+	minMonthly: backupCountSchema,
+	maxMonthly: backupCountSchema,
+}) satisfies z.ZodType<ZeropsBackupRetentionPolicy, z.ZodTypeDef, unknown>
+
+/** A service's own retention that does not parse fails the whole read: reading it as absent would send the default over it. */
+export const backupConfigSchema = z.object({
+	backupPeriod: z.string(),
+	defaultRetentionPolicy: backupRetentionPolicySchema,
+	retentionPolicy: backupRetentionPolicySchema.nullish(),
+}).transform(({ backupPeriod, defaultRetentionPolicy, retentionPolicy }): ZeropsBackupConfig => ({
+	backupPeriod,
+	defaultRetentionPolicy,
+	...(retentionPolicy === null || retentionPolicy === undefined ? {} : { retentionPolicy }),
+}))
+
 export const projectSchema = z.object({
 	id: idSchema,
 	name: z.string(),

package/src/api/types.ts

@@ -196,6 +196,34 @@ export interface ZeropsServiceAutoscaling {
 	}
 }
 
+/**
+ * How many backups of a managed service the platform keeps. VERIFIED AS A SHAPE: `OutDtoBackupRetentionPolicy` and
+ * `InDtoBodyBackupRetentionPolicy` carry these nine fields, all required. The `min*`/`max*` counts are per backup TAG
+ * (`daily`, `weekly`, `monthly`); UNVERIFIED: which tags an hourly automatic backup gets.
+ */
+export interface ZeropsBackupRetentionPolicy {
+	maxTotalFiles: number
+	maxTotalGiB: number
+	/** Backups with one of these tags are never deleted automatically. */
+	protectedTags: string[]
+	minDaily: number
+	maxDaily: number
+	minWeekly: number
+	maxWeekly: number
+	minMonthly: number
+	maxMonthly: number
+}
+
+/** A managed service's backup schedule and retention. VERIFIED AS A SHAPE: `ResponseServiceStackBackupFileList`, without its `files`. */
+export interface ZeropsBackupConfig {
+	/** UNVERIFIED: the format. Zerops' GUI documentation describes a 5-field cron (`min hour dom mon dow`). */
+	backupPeriod: string
+	/** What the platform applies to a service with no retention of its own. UNVERIFIED: that it is what applies then. */
+	defaultRetentionPolicy: ZeropsBackupRetentionPolicy
+	/** The service's own retention; absent when none was set. */
+	retentionPolicy?: ZeropsBackupRetentionPolicy
+}
+
 /** One service. VERIFIED: `ResponseServiceStack` (narrowed to the fields fabrika reads). */
 export interface ZeropsService {
 	id: string
@@ -472,6 +500,18 @@ export interface ZeropsApi {
 	 */
 	enableSubdomainAccess(input: { serviceId: string; signal: AbortSignal }): Promise<void>
 
+	// ── service-stack: running state ──────────────────────────────────────────────
+
+	/**
+	 * Start a stopped service. VERIFIED AS A SHAPE: `PUT /service-stack/{id}/start` (`StartServiceStack`), no body,
+	 * `ResponseProcess`. Measured 2026-10-21: a stopped Bun service served again about 9 s after the call. Files written
+	 * at runtime survive a stop and a start; a deploy replaces the container and loses them.
+	 */
+	startService(input: { serviceId: string; signal: AbortSignal }): Promise<ZeropsProcess>
+
+	/** Stop a service. VERIFIED AS A SHAPE: `PUT /service-stack/{id}/stop` (`StopServiceStack`), no body, `ResponseProcess`. */
+	stopService(input: { serviceId: string; signal: AbortSignal }): Promise<ZeropsProcess>
+
 	// ── service-stack: autoscaling ────────────────────────────────────────────────
 
 	/**
@@ -494,6 +534,30 @@ export interface ZeropsApi {
 	 */
 	configureCustomAutoscaling(input: { serviceId: string; autoscaling: ZeropsServiceAutoscaling; signal: AbortSignal }): Promise<ZeropsProcess | null>
 
+	// ── service-stack: backups ────────────────────────────────────────────────────
+
+	/**
+	 * A managed service's backup schedule and retention. VERIFIED AS A SHAPE: `GET /service-stack/{id}/backup`
+	 * (`ListBackups`), response `ResponseServiceStackBackupFileList`; the backup files it also lists are not read.
+	 */
+	getBackupConfig(input: { serviceId: string; signal: AbortSignal }): Promise<ZeropsBackupConfig>
+
+	/**
+	 * Set a managed service's backup schedule and retention. VERIFIED AS A SHAPE: `PUT /service-stack/{id}/backup-config`
+	 * (`ConfigureBackup`), body `RequestServiceStackBackupConfig`, response `ResponseProcessNil`. The platform stores the
+	 * period as the service's `BACKUP_PERIOD` variable and may start a user-data sync, whose process this answers.
+	 *
+	 * `retentionPolicy` is required here although the body makes it optional. UNVERIFIED: whether a request without one
+	 * resets the service's retention; a PUT elsewhere on this API resets every field it leaves out, so the caller sends
+	 * the retention it read, whole.
+	 */
+	configureBackup(input: {
+		serviceId: string
+		backupPeriod: string
+		retentionPolicy: ZeropsBackupRetentionPolicy
+		signal: AbortSignal
+	}): Promise<ZeropsProcess | null>
+
 	// ── service-stack / project: reading state ────────────────────────────────────
 
 	/** One service by id. VERIFIED: `GET /service-stack/{id}`. */

package/src/api.ts

@@ -19,6 +19,8 @@ export {
 	type ZeropsAppVersion,
 	type ZeropsAppVersionStatus,
 	type ZeropsAppVersionUpload,
+	type ZeropsBackupConfig,
+	type ZeropsBackupRetentionPolicy,
 	type ZeropsImportedService,
 	type ZeropsImportResult,
 	type ZeropsIntegrationToken,

package/src/cli.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import type { AppCli } from '@fabrika/provider-contract/app-cli'
 import { constants } from 'node:fs'
 import { open } from 'node:fs/promises'
 import { resolve } from 'node:path'
@@ -12,6 +13,7 @@ import {
 	manifestServiceHostnames,
 	ZEROPS_SOURCE_DESCRIPTOR_MAX_BYTES,
 } from './manifest'
+import { zeropsNamespaceCli } from './namespace-cli'
 import type { ZeropsAppConfig } from './types'
 
 const USAGE = `Zerops app tools
@@ -106,6 +108,15 @@ export const runZeropsCli = async (argv: readonly string[]): Promise<void> => {
 	console.info(`wrote ${output} (${manifestServiceHostnames(manifest).length} service(s))`)
 }
 
+/** What `fabrika app build`, `app register` and `fabrika namespace` run for an application on Zerops. */
+export const appCli: AppCli = {
+	provider: 'zerops',
+	entryRuntime: 'bun',
+	build: (argv) => runZeropsCli(['build', ...argv]),
+	registrationManifest: buildZeropsManifestText,
+	namespaces: zeropsNamespaceCli,
+}
+
 if (import.meta.main) {
 	await runZeropsCli(process.argv.slice(2)).catch((error: unknown) => {
 		console.error(error instanceof Error ? error.message : String(error))

package/src/collaborators.ts

@@ -1,5 +1,3 @@
-import { reconcileSchema } from '@fabrika/auth'
-import type { SchemaReconciler } from '@fabrika/provider-contract'
 import { createZeropsApi, type ZeropsApi } from './api'
 import { type ExposureAlerter, sendExposureAlert } from './exposure'
 import type { ZeropsSourcePort } from './source/port'
@@ -28,7 +26,6 @@ export interface ZeropsCollaborators {
 	api: ZeropsApi
 	/** Injected by the Zerops control composition; dry runs do not require it. */
 	source?: ZeropsSourcePort
-	reconcileSchema: SchemaReconciler
 	/** Raises the Operations alert for a refused activation; best-effort. */
 	alertExposure: ExposureAlerter
 	sleep: Sleeper
@@ -36,19 +33,8 @@ export interface ZeropsCollaborators {
 
 export type ZeropsCollaboratorFactory = (target: ZeropsRuntimeTarget) => ZeropsCollaborators
 
-const defaultReconcileSchema: SchemaReconciler = (input) =>
-	reconcileSchema({
-		url: input.url,
-		app: input.app,
-		schema: input.schema,
-		...(input.returnOrigins === undefined ? {} : { returnOrigins: input.returnOrigins }),
-		adminKey: input.adminKey,
-		signal: input.signal,
-	})
-
 export const defaultZeropsCollaborators: ZeropsCollaboratorFactory = (target) => ({
 	api: createZeropsApi({ token: target.accessToken, baseUrl: target.apiBaseUrl }),
-	reconcileSchema: defaultReconcileSchema,
 	alertExposure: sendExposureAlert,
 	sleep: defaultSleep,
 })

package/src/control.ts

@@ -1,4 +1,3 @@
-import { appEnvironmentId } from '@fabrika/auth-core'
 import type {
 	ControlProvider,
 	JsonValue,
@@ -8,6 +7,7 @@ import type {
 	ProviderDeployInput,
 	ProviderDeploymentNamespace,
 	ProviderDeployOutcome,
+	ProviderDevEnvironmentInput,
 	ProviderEnvelope,
 	ProviderEnvironment,
 	ProviderReconcileOutcome,
@@ -16,7 +16,6 @@ import type {
 	ProviderSourceBinding,
 	ProviderSourceResolution,
 	ProviderSourceResolutionInput,
-	SchemaReconciler,
 } from '@fabrika/provider-contract'
 import { decodeEnvelope, ProviderSecretError } from '@fabrika/provider-contract'
 import { z } from 'zod'
@@ -31,9 +30,8 @@ import {
 } from './api'
 import { defaultSleep, defaultZeropsCollaborators, type Sleeper } from './collaborators'
 import { createdServices, type ExposureAlerter, isObjectStorageType } from './exposure'
-import { assertAuthoredManagedInputs, assertAuthoredManagedName, assertNoFrameworkReference, parseManagedEnvironment } from './managed-env'
+import { assertAuthoredManagedInputs, assertAuthoredManagedName, assertNoFrameworkReference } from './managed-env'
 import {
-	approvedSchemaOf,
 	assertFabrikaManifestCoordinates,
 	type FabrikaManifest,
 	manifestServiceHostnames,
@@ -90,11 +88,8 @@ const envelope = <T>(codec: ProviderCodec<T>, value: T): ProviderEnvelope => ({
 export interface ZeropsControlProviderOptions {
 	readonly accessToken: string
 	readonly apiBaseUrl?: string
-	readonly propustkaUrl?: string
-	readonly adminKey?: string
 	readonly api?: ZeropsApi
 	readonly source: ZeropsSourcePort
-	readonly reconcileSchema?: SchemaReconciler
 	readonly alertExposure?: ExposureAlerter
 	readonly sleep?: Sleeper
 	readonly namespaces?: {
@@ -102,6 +97,8 @@ export interface ZeropsControlProviderOptions {
 		readonly proxySource: ZeropsNamespaceProxySource
 		readonly iamUrl: string
 		readonly iamKey: string
+		/** The installation's own project, which no namespace may adopt. */
+		readonly installationProjectId?: string
 		/** The manifest parsers of the older releases' proxies, which a namespace pinned to an older source may run. */
 		readonly olderProxies: OlderProxyReaders
 	}
@@ -226,7 +223,6 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 		return {
 			api,
 			source: options.source,
-			reconcileSchema: options.reconcileSchema ?? defaults.reconcileSchema,
 			alertExposure: options.alertExposure ?? defaults.alertExposure,
 			sleep: options.sleep ?? defaultSleep,
 		}
@@ -260,34 +256,6 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 		}
 	}
 
-	const reconcileActiveSchema = async (
-		input: { environment: ProviderEnvironment; returnOrigins?: readonly string[] },
-		signal: AbortSignal,
-	): Promise<void> => {
-		const artifact = artifactFor(input.environment)
-		const schema = approvedSchemaOf(input.environment)
-		if (schema === undefined || options.propustkaUrl === undefined) return
-		const placement = resolvedEnvironment(input.environment, { requireReady: false })
-		const runtimeTarget: ZeropsRuntimeTarget = {
-			projectId: placement.projectId,
-			serviceId: placement.target.serviceId,
-			accessToken: options.accessToken,
-			...(options.apiBaseUrl !== undefined ? { apiBaseUrl: options.apiBaseUrl } : {}),
-			propustkaUrl: options.propustkaUrl,
-			...(options.adminKey !== undefined ? { adminKey: options.adminKey } : {}),
-		}
-		const reconcileSchema = options.reconcileSchema ?? defaultZeropsCollaborators(runtimeTarget).reconcileSchema
-		signal.throwIfAborted()
-		await reconcileSchema({
-			url: options.propustkaUrl,
-			app: appEnvironmentId(artifact.app.id, artifact.app.env),
-			schema,
-			...(input.returnOrigins === undefined || input.returnOrigins.length === 0 ? {} : { returnOrigins: input.returnOrigins }),
-			adminKey: options.adminKey,
-			signal,
-		})
-	}
-
 	const assertVersionCoordinates = (environment: ProviderEnvironment, appVersionId: string, version: ZeropsAppVersion): void => {
 		const serviceId = decodeEnvironment(environment).target.serviceId
 		if (version.id !== appVersionId || (version.serviceStackId !== undefined && version.serviceStackId !== serviceId)) {
@@ -322,9 +290,31 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 		return { commitSha: result.commitSha }
 	}
 
+	/** Stop or start the service of a `dev` environment outside a run, and wait for the platform's process. */
+	const runningState = async (input: ProviderDevEnvironmentInput, action: 'start' | 'stop'): Promise<void> => {
+		if (input.environment.kind !== 'dev') throw new Error('zerops: only a dev environment is stopped and started outside a run')
+		const placement = resolvedEnvironment(input.environment, { requireReady: false })
+		const serviceId = placement.target.serviceId
+		// Idempotent: Control's record of a stopped service can lag behind a start from elsewhere.
+		const status = (await api.getService({ serviceId, signal: input.signal })).status
+		if (status === (action === 'stop' ? 'STOPPED' : 'ACTIVE')) return
+		const process = action === 'stop'
+			? await api.stopService({ serviceId, signal: input.signal })
+			: await api.startService({ serviceId, signal: input.signal })
+		await waitForProcess({
+			api,
+			processId: process.id,
+			sleep: options.sleep ?? defaultSleep,
+			signal: input.signal,
+			label: `the ${action} of ${input.environment.appId}/${input.environment.env}`,
+		})
+	}
+
 	const controlProvider: ControlProvider = {
 		id: 'zerops',
 		normalizeRegistration,
+		// The deploy reads `zerops.yaml` from the repository, so a workspace may not change it (ADR-0049 D6).
+		authoring: { protectedFiles: ['zerops.yaml', 'zerops.yml'] },
 		source: { binding: 'connection' },
 		/**
 		 * A Zerops artifact IS the compiled manifest, so the declaration is right here and core can refuse
@@ -347,8 +337,6 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 		deploy: async (input: ProviderDeployInput): Promise<ProviderDeployOutcome> => {
 			input.signal.throwIfAborted()
 			assertAuthoredManagedInputs({ variableNames: Object.keys(input.vars), secretNames: Object.keys(input.secrets) })
-			const handed = parseManagedEnvironment(input.managedEnvironment)
-			const managedEnvironment = { ...handed.values, ...handed.familyVariables }
 			const binding = privateBinding(input.sourceBinding)
 			assertEnvironmentOfApp(input.app, input.environment)
 			const placement = resolvedEnvironment(input.environment, { requireReady: true })
@@ -374,16 +362,14 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 				...(placement.target.createdBuckets === undefined ? {} : { createdBuckets: placement.target.createdBuckets }),
 				...(source === undefined ? {} : { source }),
 				...(options.apiBaseUrl !== undefined ? { apiBaseUrl: options.apiBaseUrl } : {}),
-				...(options.propustkaUrl !== undefined ? { propustkaUrl: options.propustkaUrl } : {}),
-				...(options.adminKey !== undefined ? { adminKey: options.adminKey } : {}),
 			}
 			const result = await deployRun({
 				appId: input.app.id,
 				env: input.environment.env,
-				...(input.returnOrigins === undefined ? {} : { returnOrigins: input.returnOrigins }),
+				...(input.environment.kind === 'dev' && source !== undefined ? { dev: { head: source.commitSha } } : {}),
 				secrets: input.secrets,
 				vars: input.vars,
-				managedEnvironment,
+				managedEnvironment: input.managedEnvironment,
 				target: runtimeTarget,
 				artifact,
 				...(input.environment.access === undefined ? {} : { access: input.environment.access }),
@@ -395,6 +381,10 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 			input.signal.throwIfAborted()
 			return { state: result.status, ...(result.artifactState === undefined ? {} : { artifactState: result.artifactState }) }
 		},
+		devEnvironments: {
+			stop: (input) => runningState(input, 'stop'),
+			start: (input) => runningState(input, 'start'),
+		},
 		cancel: async (input): Promise<ProviderCancelOutcome> => {
 			const signal = input.signal
 			signal.throwIfAborted()
@@ -412,17 +402,8 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 			const version = await getVersion({ appVersionId: checkpoint.appVersionId, signal })
 			if (version === null) return { state: 'settled', outcome: 'failed' }
 			assertVersionCoordinates(input.environment, checkpoint.appVersionId, version)
-			// Cancellation never implies rollback: a version that activated first makes the run a success,
-			// which finishes the same IAM touchpoint a deploy does.
-			if (version.status === ZEROPS_ACTIVE) {
-				try {
-					await reconcileActiveSchema(input, signal)
-				} catch {
-					signal.throwIfAborted()
-					return { state: 'pending' }
-				}
-				return { state: 'settled', outcome: 'succeeded' }
-			}
+			// Cancellation never implies rollback: a version that activated first makes the run a success.
+			if (version.status === ZEROPS_ACTIVE) return { state: 'settled', outcome: 'succeeded' }
 			if (version.status !== undefined && ZEROPS_TERMINAL.has(version.status)) return { state: 'settled', outcome: 'failed' }
 			await cancelBuildQuietly(checkpoint.appVersionId, signal)
 			// A build request that never landed leaves the version UPLOADING for good; the deadline settles it.
@@ -459,10 +440,7 @@ export const createZeropsControlProvider = (options: ZeropsControlProviderOption
 			}
 			if (version === null) return { state: 'failed' }
 			assertVersionCoordinates(input.environment, checkpoint.appVersionId, version)
-			if (version.status === ZEROPS_ACTIVE) {
-				await reconcileActiveSchema(input, signal)
-				return { state: 'succeeded' }
-			}
+			if (version.status === ZEROPS_ACTIVE) return { state: 'succeeded' }
 			if (version.status !== undefined && ZEROPS_TERMINAL.has(version.status)) return { state: 'failed' }
 			if (pastDeadline(input.startedAtMs)) {
 				await cancelBuildQuietly(checkpoint.appVersionId, signal)