@dragonmastery/tamer 0.1.2 → 0.29.0

package/dist/StateManager-DTqtLLVX.mjs

@@ -0,0 +1,760 @@
+import { a as boolean, c as number, d as string, i as array, l as object, n as _enum, o as discriminatedUnion, s as literal, t as StateConflictError, u as record } from "./tamer.mjs";
+
+//#region src/core/state/stateSchema.ts
+const D1StateEntrySchema = object({
+	type: literal("d1_database"),
+	logicalName: string(),
+	shardDate: string().optional(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	migrationsDir: string().optional(),
+	preserveOnDestroy: boolean().optional(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const R2StateEntrySchema = object({
+	type: literal("r2_bucket"),
+	logicalName: string(),
+	createdDate: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const KVStateEntrySchema = object({
+	type: literal("kv_namespace"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const QueueStateEntrySchema = object({
+	type: literal("queue"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	producerBinding: boolean(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const VectorizeStateEntrySchema = object({
+	type: literal("vectorize"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	dimensions: number(),
+	metric: _enum([
+		"cosine",
+		"euclidean",
+		"dot-product"
+	]),
+	createdAt: string(),
+	updatedAt: string()
+});
+const AIGatewayStateEntrySchema = object({
+	type: literal("ai_gateway"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	cacheTtl: number(),
+	cacheInvalidateOnUpdate: boolean(),
+	collectLogs: boolean(),
+	authentication: boolean(),
+	rateLimitingInterval: number(),
+	rateLimitingLimit: number(),
+	rateLimitingTechnique: _enum(["fixed", "sliding"]),
+	createdAt: string(),
+	updatedAt: string()
+});
+const PipelineStateEntrySchema = object({
+	type: literal("pipeline"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	sql: string(),
+	status: string().optional(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const WorkflowStateEntrySchema = object({
+	type: literal("workflow"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	className: string(),
+	scriptName: string(),
+	limits: object({ steps: number().int().positive().optional() }).optional(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const SecretsStoreStateEntrySchema = object({
+	type: literal("secrets_store"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const HyperdriveStateEntrySchema = object({
+	type: literal("hyperdrive"),
+	logicalName: string(),
+	derivedName: string(),
+	bindingKey: string(),
+	cfId: string(),
+	scheme: _enum([
+		"postgres",
+		"postgresql",
+		"mysql"
+	]),
+	originHost: string(),
+	originDatabase: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const DnsRecordTypeSchema = _enum([
+	"A",
+	"AAAA",
+	"CNAME",
+	"TXT",
+	"MX",
+	"NS",
+	"CAA",
+	"SRV",
+	"PTR",
+	"HTTPS",
+	"SVCB"
+]);
+const DnsRecordStateEntrySchema = object({
+	type: literal("dns_record"),
+	logicalName: string(),
+	zoneId: string(),
+	recordType: DnsRecordTypeSchema,
+	name: string(),
+	content: string(),
+	ttl: number(),
+	proxied: boolean(),
+	priority: number().optional(),
+	comment: string(),
+	recordId: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const DispatchNamespaceStateEntrySchema = object({
+	type: literal("dispatch_namespace"),
+	logicalName: string(),
+	derivedName: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const LogpushJobStateEntrySchema = object({
+	type: literal("logpush_job"),
+	logicalName: string(),
+	derivedName: string(),
+	cfJobId: number(),
+	dataset: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const LogpushPipelinesStateEntrySchema = object({
+	type: literal("logpush_pipelines"),
+	logicalName: string(),
+	streamId: string(),
+	streamIngestBaseUrl: string().optional(),
+	sinkId: string(),
+	pipelineId: string(),
+	streamName: string(),
+	sinkName: string(),
+	pipelineName: string(),
+	r2DataCatalogTableName: string().optional(),
+	r2DataCatalogTableNamePipelines: string().optional(),
+	r2DataCatalogNamespace: string().optional(),
+	catalogBucketDerivedName: string(),
+	mintedR2CatalogTokenId: string().optional(),
+	mintedR2CatalogTokenValue: string().optional(),
+	mintedPipelinesSendTokenId: string().optional(),
+	mintedPipelinesSendTokenValue: string().optional(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const WorkerRouteStateEntrySchema = object({
+	type: literal("worker_route"),
+	workerKey: string(),
+	workerName: string(),
+	zoneId: string(),
+	zoneName: string(),
+	routeId: string(),
+	pattern: string(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const StateEntrySchema = discriminatedUnion("type", [
+	D1StateEntrySchema,
+	R2StateEntrySchema,
+	KVStateEntrySchema,
+	QueueStateEntrySchema,
+	HyperdriveStateEntrySchema,
+	VectorizeStateEntrySchema,
+	AIGatewayStateEntrySchema,
+	PipelineStateEntrySchema,
+	WorkflowStateEntrySchema,
+	SecretsStoreStateEntrySchema,
+	DnsRecordStateEntrySchema,
+	DispatchNamespaceStateEntrySchema,
+	LogpushJobStateEntrySchema,
+	LogpushPipelinesStateEntrySchema,
+	WorkerRouteStateEntrySchema
+]);
+const ProvisioningStatusSchema = _enum([
+	"pending",
+	"d1_created",
+	"migrations_applied",
+	"script_uploaded",
+	"ready",
+	"tombstoned"
+]);
+const TenantD1ShardRefSchema = object({
+	role: string(),
+	derivedName: string(),
+	cfId: string()
+});
+const TenantStateEntrySchema = object({
+	product: string(),
+	workspace: string(),
+	provisioningStatus: ProvisioningStatusSchema,
+	dispatchNamespaceName: string(),
+	scriptName: string(),
+	d1Shards: array(TenantD1ShardRefSchema).optional(),
+	createdAt: string(),
+	updatedAt: string()
+});
+const CfiStackMetaSchema = object({
+	name: string().optional(),
+	owner: string().optional()
+});
+const CfiOperationNameSchema = _enum([
+	"bootstrap",
+	"apply",
+	"deploy",
+	"destroy",
+	"provision-tenant",
+	"destroy-tenant",
+	"import",
+	"sync"
+]);
+const CfiOperationStatusSchema = _enum([
+	"in_progress",
+	"succeeded",
+	"failed"
+]);
+const CfiStackOutputValueSchema = object({
+	value: string(),
+	source: string(),
+	resolvedAt: string()
+});
+const CfiOperationRecordSchema = object({
+	command: CfiOperationNameSchema,
+	status: CfiOperationStatusSchema,
+	startedAt: string(),
+	completedAt: string().optional(),
+	errorMessage: string().optional(),
+	detail: string().optional()
+});
+const CfiStateSchema = object({
+	tenantId: string(),
+	env: string(),
+	schemaVersion: number(),
+	syncedAt: string(),
+	resources: record(string(), StateEntrySchema),
+	revision: number().optional(),
+	tenants: record(string(), TenantStateEntrySchema).optional(),
+	stack: CfiStackMetaSchema.optional(),
+	stackOutputs: record(string(), CfiStackOutputValueSchema).optional(),
+	lastOperation: CfiOperationRecordSchema.optional(),
+	operationHistory: array(CfiOperationRecordSchema).optional()
+});
+
+//#endregion
+//#region src/core/state/stackName.ts
+const DEFAULT_STACK_NAME = "default";
+function stackNameForConfig(config) {
+	return config.stack?.name ?? config.tenant.slug ?? DEFAULT_STACK_NAME;
+}
+
+//#endregion
+//#region src/core/state/tamerStateDb.ts
+/**
+* Schema versions:
+*   2: original (resources only).
+*   3: + `tenants` map, + `revision` for optimistic concurrency.
+*   4: + `stack` metadata, + `lastOperation` (CloudFormation-style stack info).
+*      All v4 additions are optional; existing v3 documents are upgraded
+*      in-place during parse with no data loss.
+*/
+const STATE_SCHEMA_VERSION = 4;
+/** Cloudflare D1 database that holds JSON state for an env (`tamer-state-dev`, …). */
+function tamerStateDatabaseName(env) {
+	return `tamer-state-${env}`;
+}
+function createEmptyCfiState(tenantId, env) {
+	return {
+		tenantId,
+		env,
+		schemaVersion: STATE_SCHEMA_VERSION,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		resources: {},
+		revision: 0,
+		tenants: {}
+	};
+}
+/** In-place upgrade for parsed JSON before Zod validation. */
+function migrateRawCfiStateInPlace(raw) {
+	const v = raw.schemaVersion;
+	if (typeof v !== "number") throw new Error("tamer state: schemaVersion must be a number");
+	if (v < 2) throw new Error(`tamer state: unsupported schemaVersion ${v}`);
+	if (v > STATE_SCHEMA_VERSION) throw new Error(`tamer state: unknown schemaVersion ${v} (engine supports up to ${STATE_SCHEMA_VERSION})`);
+	if (v === 2) {
+		raw.tenants = {};
+		raw.revision = 0;
+		raw.schemaVersion = 3;
+	}
+	if (!raw.tenants || typeof raw.tenants !== "object") raw.tenants = {};
+	if (typeof raw.revision !== "number") raw.revision = 0;
+	if (raw.schemaVersion === 3) raw.schemaVersion = STATE_SCHEMA_VERSION;
+}
+async function findTamerStateDatabaseUuid(api, env) {
+	const name = tamerStateDatabaseName(env);
+	return (await api.d1ListAll()).find((d) => d.name === name)?.uuid;
+}
+/**
+* Create `tamer-state-{env}` if missing, ensure `tamer_kv` table, and seed an
+* initial empty `cfi_state:{stackName}` row when this stack has no row yet.
+* Idempotent — re-running for the same stack is a no-op; re-running for a
+* different stack against the same env D1 just adds another row.
+*/
+async function ensureTamerStateDatabase(api, tenantId, env, stackName = DEFAULT_STACK_NAME) {
+	let uuid = await findTamerStateDatabaseUuid(api, env);
+	if (!uuid) uuid = (await api.d1Create(tamerStateDatabaseName(env))).uuid;
+	await api.d1Query(uuid, `CREATE TABLE IF NOT EXISTS tamer_kv (
+      k TEXT PRIMARY KEY,
+      v TEXT NOT NULL
+    )`);
+	const rowKey = `cfi_state:${stackName}`;
+	const { rows } = await api.d1Query(uuid, `SELECT v FROM tamer_kv WHERE k = ?`, [rowKey]);
+	if (rows.length === 0) {
+		const initial = createEmptyCfiState(tenantId, env);
+		await api.d1Query(uuid, `INSERT INTO tamer_kv (k, v) VALUES (?, ?)`, [rowKey, JSON.stringify(initial)]);
+	}
+	return uuid;
+}
+function parseCfiStateJson(json) {
+	const raw = JSON.parse(json);
+	migrateRawCfiStateInPlace(raw);
+	const result = CfiStateSchema.safeParse(raw);
+	if (!result.success) throw new Error(`Invalid tamer state JSON: ${result.error.message}`);
+	return result.data;
+}
+async function destroyTamerStateDatabase(api, env) {
+	const uuid = await findTamerStateDatabaseUuid(api, env);
+	if (!uuid) return false;
+	await api.d1Delete(uuid);
+	return true;
+}
+
+//#endregion
+//#region src/features/dispatch-namespace/dispatch-namespace.resolve.ts
+const ephemeralPredicateCache = /* @__PURE__ */ new WeakMap();
+function ephemeralPredicateFor(tenant) {
+	if (ephemeralPredicateCache.has(tenant)) return ephemeralPredicateCache.get(tenant) ?? null;
+	const pat = tenant.ephemeralEnvPattern;
+	const compiled = pat ? new RegExp(pat) : null;
+	ephemeralPredicateCache.set(tenant, compiled);
+	return compiled;
+}
+/**
+* `true` when `env` matches `tenant.ephemeralEnvPattern` (e.g.
+* `"^pr-"` for PR previews, `"^(pr|feature)-"` for branch previews).
+*
+* Ephemeral envs share **one** dispatch namespace
+* (`{ns}-ephemeral`) so we don't churn dispatch-namespace creates per
+* preview, and dispatch-script names carry the env suffix
+* (`{product}-{workspace}-{env}`) so multiple previews can coexist
+* inside that shared namespace. When the config doesn't pin a
+* pattern, no env is ephemeral — every env gets its own dispatch
+* namespace `{ns}-{env}`.
+*/
+function isEphemeralEnv(env, tenant) {
+	const re = ephemeralPredicateFor(tenant);
+	if (!re) return false;
+	return re.test(env);
+}
+/** Resolved Cloudflare dispatch namespace name for the given env. */
+function effectiveDispatchNamespaceName(config, env, tenant) {
+	if (config.envSuffix) {
+		if (env === "local") return config.namespace;
+		if (isEphemeralEnv(env, tenant)) return `${config.namespace}-ephemeral`;
+		return `${config.namespace}-${env}`;
+	}
+	return config.namespace;
+}
+
+//#endregion
+//#region src/core/tenant/tenantKeys.ts
+/** Stable map key for `CfiState.tenants` (workspace-scoped product tenant). */
+function tenantStateKey(product, workspace) {
+	return `${product}:${workspace}`;
+}
+/**
+* Dispatch-namespace script name per `docs/handoff.md` §6: non-ephemeral
+* envs collapse to `{product}-{workspace}` (one script per workspace);
+* ephemeral envs (matching `tenant.ephemeralEnvPattern`) carry the env
+* in the script name (`{product}-{workspace}-{env}`) so multiple
+* previews can coexist in the shared `{ns}-ephemeral` namespace.
+*/
+function tenantDispatchScriptName(product, workspace, env, tenant) {
+	if (isEphemeralEnv(env, tenant)) return `${product}-${workspace}-${env}`;
+	return `${product}-${workspace}`;
+}
+const SAFE = /[^a-z0-9_-]/gi;
+/**
+* Per-shard D1 database name for a tenant. Stable across `provision-tenant`
+* runs and across env so re-provisioning + drift detection can match by
+* name. Format: `db_{role}_{w}_{p}_t_{tid}_{env}`.
+*
+*   db_system_acme_todo_t_platform_prod
+*   db_app_acme_todo_t_platform_prod
+*
+* `role` is whatever the operator declared in `tenant.d1Shards` in
+* `tamer.config.ts`. Tamer is opinion-free about the shard layout — a
+* Dragoncore-style product picks `["system", "app", "history"]`, a
+* single-DB tenant picks `["main"]`, an audit-only tenant picks
+* `["audit"]`, etc. The role itself is validated by the loader (lowercase
+* ASCII subset) so it slots cleanly into the D1 naming scheme.
+*
+* D1 names are length-bounded (Cloudflare currently allows up to 64
+* chars), and this scheme keeps every shard well under that limit even
+* for long workspace + product slugs.
+*/
+function tenantShardDatabaseName(role, workspace, product, platformTenantId, env) {
+	return `db_${role}_${workspace.replace(SAFE, "_").toLowerCase()}_${product.replace(SAFE, "_").toLowerCase()}_t_${platformTenantId}_${env}`;
+}
+/**
+* Parse + validate a `--shards a,b,c` CLI argument against the configured
+* shard set in `tamer.config.ts`. The CLI flag may only **trim** the
+* configured layout (e.g. `--shards system` on a stack whose config
+* declares `["system","app","history"]` provisions just the system
+* shard for an ephemeral preview); it cannot extend it, because the
+* config is the source of truth that `apply` / `drift` / `destroy`
+* other operators read.
+*
+* Returns the requested roles in canonical order (matches `allowed`
+* order, regardless of input order) so plan/apply output is
+* deterministic and partial-failure resumes pick up at the next
+* canonical role.
+*/
+function parseTenantShardRoles(raw, allowed) {
+	const allowedSet = new Set(allowed);
+	const requested = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+	const unknown = requested.filter((r) => !allowedSet.has(r));
+	if (unknown.length > 0) {
+		const list = allowed.length > 0 ? allowed.join(", ") : "(none configured)";
+		throw new Error(`unknown tenant shard role(s) "${unknown.join(", ")}"; must be a subset of tenant.d1Shards in the Tamer project config: ${list}`);
+	}
+	const seen = new Set(requested);
+	return allowed.filter((r) => seen.has(r));
+}
+
+//#endregion
+//#region src/core/state/StateManager.ts
+/** D1 `tamer_kv.k` value for a given stack's state row. */
+function stateRowKey(stackName) {
+	return `cfi_state:${stackName}`;
+}
+const OPERATION_HISTORY_CAP = 50;
+/**
+* Authoritative deployment state for an env.
+*
+* - **Non-local:** stored as JSON in Cloudflare D1 (`tamer-state-{env}`).
+*   Call {@link hydrate} before {@link load}, then {@link persist} after mutations.
+* - **local:** in-memory only (no persistence).
+*/
+var StateManager = class {
+	state = null;
+	dirty = false;
+	/** Set when {@link hydrate} loads remote state. */
+	tamerStateDbUuid = null;
+	/**
+	* Remote `revision` at last hydrate (or last successful persist). Used for
+	* optimistic concurrency on D1 persist.
+	*/
+	baselineRevision = 0;
+	/**
+	* @param tenantId  `config.tenant.id` — recorded on the state row for
+	*                  diagnostics; not part of the row key.
+	* @param env       Cloudflare environment name; selects the
+	*                  `tamer-state-{env}` D1 database.
+	* @param stackName Stack identity (`config.stack.name ?? tenant.slug`).
+	*                  The state row in D1 is keyed `cfi_state:{stackName}`,
+	*                  so multiple stacks coexist in one env D1 without
+	*                  clobbering each other. Defaults to `"default"` —
+	*                  unit tests that synthesize a StateManager without
+	*                  a config get a stable key without extra plumbing.
+	*/
+	constructor(tenantId, env, stackName = DEFAULT_STACK_NAME) {
+		this.tenantId = tenantId;
+		this.env = env;
+		this.stackName = stackName;
+	}
+	/**
+	* Load state from D1 (remote) or allocate empty state (local).
+	* Required before {@link load} for every command.
+	*/
+	async hydrate(api) {
+		if (this.state) return;
+		if (this.env === "local") {
+			this.state = createEmptyCfiState(this.tenantId, this.env);
+			this.baselineRevision = this.state.revision ?? 0;
+			return;
+		}
+		const name = tamerStateDatabaseName(this.env);
+		const uuid = await findTamerStateDatabaseUuid(api, this.env);
+		if (!uuid) throw new Error(`Tamer state database "${name}" not found. Run: tamer bootstrap --env ${this.env}`);
+		this.tamerStateDbUuid = uuid;
+		const rowKey = stateRowKey(this.stackName);
+		const { rows } = await api.d1Query(uuid, `SELECT v FROM tamer_kv WHERE k = ?`, [rowKey]);
+		if (rows.length === 0) {
+			this.state = createEmptyCfiState(this.tenantId, this.env);
+			this.baselineRevision = this.state.revision ?? 0;
+			this.dirty = true;
+			return;
+		}
+		const v = rows[0]["v"];
+		if (typeof v !== "string") throw new Error(`tamer_kv.${rowKey} must be a string column`);
+		this.state = parseCfiStateJson(v);
+		this.baselineRevision = this.state.revision ?? 0;
+	}
+	/**
+	* Stack identifier this manager is bound to (the `cfi_state:{name}` row
+	* key suffix). Exposed so `fetchStackImports` and diagnostics can show
+	* the operator which row this manager owns.
+	*/
+	getStackName() {
+		return this.stackName;
+	}
+	/**
+	* Allocate empty in-memory state without touching D1. Use for read-only
+	* "what-would-state-look-like" snapshots (e.g. drift-aware plan refresh)
+	* where we want to drive the module `sync` hooks against a fresh slate
+	* and then discard the result. {@link persist} is unsafe afterwards
+	* because there is no D1 baseline to compare against.
+	*/
+	hydrateInMemory() {
+		if (this.state) return;
+		this.state = createEmptyCfiState(this.tenantId, this.env);
+		this.baselineRevision = this.state.revision ?? 0;
+	}
+	/** Clear cached state so the next {@link hydrate} reloads from D1. */
+	reset() {
+		this.state = null;
+		this.tamerStateDbUuid = null;
+		this.dirty = false;
+		this.baselineRevision = 0;
+	}
+	load() {
+		if (!this.state) throw new Error("StateManager: call await hydrate(api) before load()");
+		return this.state;
+	}
+	get(derivedName) {
+		return this.load().resources[derivedName];
+	}
+	set(derivedName, entry) {
+		const s = this.load();
+		s.resources[derivedName] = entry;
+		s.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.dirty = true;
+	}
+	delete(derivedName) {
+		const s = this.load();
+		delete s.resources[derivedName];
+		s.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.dirty = true;
+	}
+	getAll() {
+		return this.load().resources;
+	}
+	getTenant(product, workspace) {
+		return this.load().tenants?.[tenantStateKey(product, workspace)];
+	}
+	setTenant(entry) {
+		const s = this.load();
+		if (!s.tenants) s.tenants = {};
+		s.tenants[tenantStateKey(entry.product, entry.workspace)] = entry;
+		s.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.dirty = true;
+	}
+	deleteTenant(product, workspace) {
+		const s = this.load();
+		if (!s.tenants) return;
+		delete s.tenants[tenantStateKey(product, workspace)];
+		s.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.dirty = true;
+	}
+	listTenants() {
+		return Object.values(this.load().tenants ?? {});
+	}
+	/** CloudFormation-style stack metadata (name, owner). Returns a copy. */
+	getStackMeta() {
+		const s = this.load().stack;
+		return s ? { ...s } : void 0;
+	}
+	/**
+	* Set or merge stack metadata. Pass `undefined` fields to clear them; only
+	* provided keys are written, so callers can update one field at a time.
+	*/
+	setStackMeta(meta) {
+		const s = this.load();
+		s.stack = {
+			...s.stack ?? {},
+			...meta
+		};
+		s.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.dirty = true;
+	}
+	/**
+	* Resolved + persisted `outputs:` for this stack. Returns `{}` when none
+	* have been recorded yet (e.g. before the first successful `apply`). The
+	* returned object is a shallow copy — mutate via {@link replaceStackOutputs}.
+	*/
+	getStackOutputs() {
+		return { ...this.load().stackOutputs ?? {} };
+	}
+	/**
+	* Replace this stack's `stackOutputs` map wholesale. Pass `{}` to clear
+	* (e.g. when `outputs` is removed from `tamer.config.ts`); pass a fresh
+	* map keyed by output name to commit a successful apply's resolved values.
+	* No-op when the new map is structurally identical to the existing one
+	* (avoids gratuitous `revision` bumps on no-op applies).
+	*/
+	replaceStackOutputs(next) {
+		const s = this.load();
+		if (stackOutputsEqual(s.stackOutputs ?? {}, next)) return;
+		if (Object.keys(next).length === 0) delete s.stackOutputs;
+		else s.stackOutputs = { ...next };
+		s.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.dirty = true;
+	}
+	getLastOperation() {
+		return this.load().lastOperation;
+	}
+	/** Completed operations (`succeeded` / `failed` only), newest first. */
+	getOperationHistory() {
+		const h = this.load().operationHistory;
+		return h ? h.map((e) => ({ ...e })) : [];
+	}
+	/**
+	* Begin recording a CloudFormation-style operation marker. Sets `status:
+	* "in_progress"` and `startedAt`; pair with {@link finishOperation} on
+	* success or {@link failOperation} on error. Persist between calls if the
+	* operation may take a long time and you want concurrent operators to see
+	* the in-progress marker.
+	*/
+	beginOperation(command, detail) {
+		const s = this.load();
+		s.lastOperation = {
+			command,
+			status: "in_progress",
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			detail
+		};
+		s.syncedAt = s.lastOperation.startedAt;
+		this.dirty = true;
+	}
+	finishOperation(detail) {
+		const s = this.load();
+		if (!s.lastOperation) return;
+		s.lastOperation.status = "succeeded";
+		s.lastOperation.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+		if (detail !== void 0) s.lastOperation.detail = detail;
+		s.syncedAt = s.lastOperation.completedAt;
+		this.appendTerminalOperationToHistory(s.lastOperation);
+		this.dirty = true;
+	}
+	failOperation(errorMessage) {
+		const s = this.load();
+		if (!s.lastOperation) return;
+		s.lastOperation.status = "failed";
+		s.lastOperation.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+		s.lastOperation.errorMessage = errorMessage;
+		s.syncedAt = s.lastOperation.completedAt;
+		this.appendTerminalOperationToHistory(s.lastOperation);
+		this.dirty = true;
+	}
+	appendTerminalOperationToHistory(op) {
+		if (op.status !== "succeeded" && op.status !== "failed") return;
+		const s = this.load();
+		s.operationHistory = [{
+			command: op.command,
+			status: op.status,
+			startedAt: op.startedAt,
+			completedAt: op.completedAt,
+			errorMessage: op.errorMessage,
+			detail: op.detail
+		}, ...s.operationHistory ?? []].slice(0, OPERATION_HISTORY_CAP);
+	}
+	/**
+	* Persist to D1 (no-op for local). Uses optimistic concurrency: re-reads
+	* `revision` before write; throws {@link StateConflictError} if another
+	* writer advanced the row since {@link hydrate}.
+	*/
+	async persist(api) {
+		if (this.env === "local") {
+			this.dirty = false;
+			return;
+		}
+		if (!this.dirty || !this.state || !this.tamerStateDbUuid) return;
+		const rowKey = stateRowKey(this.stackName);
+		const { rows } = await api.d1Query(this.tamerStateDbUuid, `SELECT v FROM tamer_kv WHERE k = ?`, [rowKey]);
+		let remoteRev = 0;
+		if (rows.length > 0) {
+			const v = rows[0]["v"];
+			if (typeof v === "string") remoteRev = parseCfiStateJson(v).revision ?? 0;
+		}
+		if (remoteRev !== this.baselineRevision) throw new StateConflictError(`Tamer state conflict (stack=${this.stackName}): remote revision ${remoteRev} !== expected ${this.baselineRevision}. Re-run after refresh.`);
+		this.state.revision = remoteRev + 1;
+		this.state.syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const json = JSON.stringify(this.state);
+		await api.d1Query(this.tamerStateDbUuid, `INSERT INTO tamer_kv (k, v) VALUES (?, ?)
+       ON CONFLICT(k) DO UPDATE SET v = excluded.v`, [rowKey, json]);
+		this.baselineRevision = this.state.revision;
+		this.dirty = false;
+	}
+	/** Mark clean without writing (e.g. before deleting the state database). */
+	clearDirty() {
+		this.dirty = false;
+	}
+};
+function stackOutputsEqual(a, b) {
+	const ak = Object.keys(a).sort();
+	const bk = Object.keys(b).sort();
+	if (ak.length !== bk.length) return false;
+	for (let i = 0; i < ak.length; i++) {
+		if (ak[i] !== bk[i]) return false;
+		const k = ak[i];
+		const av = a[k];
+		const bv = b[k];
+		if (av.value !== bv.value || av.source !== bv.source) return false;
+	}
+	return true;
+}
+
+//#endregion
+export { tenantStateKey as a, createEmptyCfiState as c, tamerStateDatabaseName as d, stackNameForConfig as f, tenantShardDatabaseName as i, destroyTamerStateDatabase as l, parseTenantShardRoles as n, effectiveDispatchNamespaceName as o, tenantDispatchScriptName as r, isEphemeralEnv as s, StateManager as t, ensureTamerStateDatabase as u };
+//# sourceMappingURL=StateManager-DTqtLLVX.mjs.map