effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/Scheduling-C9aIP8zT.mjs

@@ -0,0 +1,691 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "./utf8-DchGZRBd.mjs";
+import { ThreadId } from "./core/Identifiers.mjs";
+import { IdempotencyKey } from "./core/Receipt.mjs";
+import { DefinitionDigests, PersistedJson } from "./durable/Records.mjs";
+import { digestJson } from "./durable/Digest.mjs";
+import { ScheduleAuthorizer, ScheduleConflict, ScheduleDestination, ScheduleFailpoint, ScheduleInstant, ScheduleNotFound, ScheduleStorageError, ScheduleStore, ScheduleTimingRequest, ScheduleValidationError, ScheduleWake, ScheduledInputAdmission, SchedulingLimits, defaultSchedulingLimits } from "./durable/Schedule.mjs";
+import { admitPreparedInput } from "./durable/PreparedInputAdmission.mjs";
+import { Cause, Context, Cron, Crypto, DateTime, Effect, Layer, Option, Result, Schema, Semaphore } from "effect";
+//#region src/durable/internal/schedule-time.ts
+const invalid = (message) => Result.fail(ScheduleValidationError.make({ message }));
+const checkedInstant = (millis, label) => Schema.decodeResult(ScheduleInstant)(millis).pipe(Result.mapError(() => ScheduleValidationError.make({ message: `${label} is outside the supported ScheduleInstant range` })));
+const values = (set, size) => set.size === 0 ? Array.from({ length: size }, (_, index) => index) : [...set];
+/**
+* Cron frequency proof without calendar enumeration. It checks the minimum circular spacing of
+* the allowed hour/minute pairs. Day restrictions may make a rule sparser, so this deliberately
+* rejects some safe rules when a configured minimum exceeds one minute.
+*/
+const validateCronFrequency = (cron, minimumMillis) => {
+	if (cron.seconds.size !== 1) return invalid("Cron must select exactly one seconds value");
+	if (minimumMillis <= 6e4) return Result.succeed(void 0);
+	if (Option.isSome(cron.tz) && DateTime.isTimeZoneNamed(cron.tz.value) && cron.tz.value.id !== "UTC") return invalid("Cron minimums above one minute require UTC or a fixed-offset time zone");
+	const minuteOfDay = values(cron.hours, 24).flatMap((hour) => values(cron.minutes, 60).map((minute) => hour * 60 + minute));
+	minuteOfDay.sort((left, right) => left - right);
+	let minimumGap = 1440;
+	for (let index = 0; index < minuteOfDay.length; index += 1) {
+		const current = minuteOfDay[index];
+		const next = minuteOfDay[(index + 1) % minuteOfDay.length];
+		if (current === void 0 || next === void 0) continue;
+		const gap = next > current ? next - current : 1440 - current + next;
+		minimumGap = Math.min(minimumGap, gap);
+	}
+	return minimumGap * 6e4 >= minimumMillis ? Result.succeed(void 0) : invalid(`Cron may fire more often than the configured ${minimumMillis}ms minimum`);
+};
+const parseScheduleCron = (expression, timeZone, minimumMillis) => {
+	const parsed = Cron.parse(expression, timeZone);
+	if (Result.isFailure(parsed)) return invalid(parsed.failure.message);
+	const frequency = validateCronFrequency(parsed.success, minimumMillis);
+	return Result.isFailure(frequency) ? Result.fail(frequency.failure) : Result.succeed(parsed.success);
+};
+const normalizeScheduleTiming = (request, nowMillis, minimumMillis) => {
+	switch (request._tag) {
+		case "At": return Result.succeed(request);
+		case "After": {
+			const at = checkedInstant(nowMillis + request.delayMillis, "Relative deadline");
+			return Result.map(at, (atMillis) => ({
+				_tag: "At",
+				atMillis
+			}));
+		}
+		case "Interval": {
+			if (request.everyMillis < minimumMillis) return invalid(`Interval must be at least ${minimumMillis}ms`);
+			const anchor = checkedInstant(request.anchorMillis ?? nowMillis + request.everyMillis, "Interval anchor");
+			return Result.map(anchor, (anchorMillis) => ({
+				_tag: "Interval",
+				everyMillis: request.everyMillis,
+				anchorMillis
+			}));
+		}
+		case "Cron": {
+			const timeZone = request.timeZone ?? "UTC";
+			const cron = parseScheduleCron(request.expression, timeZone, minimumMillis);
+			if (Result.isFailure(cron)) return Result.fail(cron.failure);
+			return Result.succeed({
+				_tag: "Cron",
+				expression: request.expression,
+				timeZone
+			});
+		}
+	}
+};
+const parsedStoredCron = (timing) => {
+	const parsed = Cron.parse(timing.expression, timing.timeZone);
+	return Result.isFailure(parsed) ? invalid(`Stored cron is invalid: ${parsed.failure.message}`) : Result.succeed(parsed.success);
+};
+/** Strictly selects the first occurrence after an instant. */
+const scheduleNextAfter = (timing, afterMillis) => {
+	switch (timing._tag) {
+		case "At": return Result.succeed(timing.atMillis > afterMillis ? timing.atMillis : null);
+		case "Interval": {
+			if (afterMillis < timing.anchorMillis) return Result.succeed(timing.anchorMillis);
+			const steps = Math.floor((afterMillis - timing.anchorMillis) / timing.everyMillis) + 1;
+			const next = timing.anchorMillis + steps * timing.everyMillis;
+			return checkedInstant(next, "Next interval occurrence");
+		}
+		case "Cron": {
+			const cron = parsedStoredCron(timing);
+			if (Result.isFailure(cron)) return Result.fail(cron.failure);
+			return Result.try({
+				try: () => {
+					let next = Cron.next(cron.success, afterMillis).getTime();
+					while (next <= afterMillis) {
+						const following = Cron.next(cron.success, next).getTime();
+						if (following <= next) throw new Error("Cron did not advance");
+						next = following;
+					}
+					return next;
+				},
+				catch: () => ScheduleValidationError.make({ message: "Cron has no supported next firing" })
+			}).pipe(Result.flatMap((next) => checkedInstant(next, "Next cron occurrence")));
+		}
+	}
+};
+/** Initial cursor. Past one-shots remain due; recurring rules start strictly after registration. */
+const scheduleInitialCursor = (timing, nowMillis) => timing._tag === "At" ? Result.succeed(timing.atMillis) : scheduleNextAfter(timing, nowMillis);
+/** Coalesces recurring occurrences using the same forward sequence as registration. */
+const scheduleDueOccurrence = (timing, cursorMillis, nowMillis) => {
+	if (cursorMillis > nowMillis) return Result.succeed(null);
+	if (timing._tag === "At") return Result.succeed({
+		intendedAtMillis: cursorMillis,
+		nextAtMillis: null,
+		skippedRange: null
+	});
+	let intendedAtMillis;
+	if (timing._tag === "Interval") {
+		const steps = Math.floor((nowMillis - timing.anchorMillis) / timing.everyMillis);
+		intendedAtMillis = Math.max(cursorMillis, timing.anchorMillis + steps * timing.everyMillis);
+	} else {
+		const cron = parsedStoredCron(timing);
+		if (Result.isFailure(cron)) return Result.fail(cron.failure);
+		const due = Result.try({
+			try: () => {
+				let intended = cursorMillis;
+				const zone = Option.getOrUndefined(cron.success.tz);
+				if (zone !== void 0 && (DateTime.isTimeZoneOffset(zone) || zone.id === "UTC")) intended = Math.max(cursorMillis, Cron.prev(cron.success, nowMillis + 1e3).getTime());
+				else {
+					const calendar = Cron.make({
+						...cron.success,
+						seconds: [0],
+						minutes: [0],
+						hours: [0],
+						tz: DateTime.zoneMakeNamedUnsafe("UTC")
+					});
+					const localDay = DateTime.makeUnsafe(DateTime.toDate(DateTime.makeZonedUnsafe(nowMillis, { timeZone: zone }))).pipe(DateTime.startOf("day"), DateTime.subtract({ days: 2 }));
+					const seedDay = Cron.prev(calendar, DateTime.toEpochMillis(localDay) + 1e3);
+					const seed = DateTime.makeZonedUnsafe(seedDay, {
+						timeZone: zone,
+						adjustForTimeZone: true
+					}).pipe(DateTime.toEpochMillis) - 1e3;
+					if (seed > cursorMillis) {
+						const first = Cron.next(cron.success, seed).getTime();
+						if (first <= nowMillis) intended = Math.max(intended, first);
+					}
+				}
+				let next = Cron.next(cron.success, intended).getTime();
+				while (next <= nowMillis) {
+					if (next <= intended) throw new Error("Cron did not advance");
+					intended = next;
+					next = Cron.next(cron.success, intended).getTime();
+				}
+				return {
+					intended,
+					next
+				};
+			},
+			catch: () => ScheduleValidationError.make({ message: "Cron has no supported due firing" })
+		});
+		if (Result.isFailure(due)) return Result.fail(due.failure);
+		const next = checkedInstant(due.success.next, "Next cron occurrence");
+		if (Result.isFailure(next)) return Result.fail(next.failure);
+		return Result.succeed({
+			intendedAtMillis: due.success.intended,
+			nextAtMillis: next.success,
+			skippedRange: due.success.intended === cursorMillis ? null : {
+				fromMillis: cursorMillis,
+				toMillis: due.success.intended
+			}
+		});
+	}
+	const next = scheduleNextAfter(timing, nowMillis);
+	if (Result.isFailure(next)) return Result.fail(next.failure);
+	return Result.succeed({
+		intendedAtMillis,
+		nextAtMillis: next.success,
+		skippedRange: intendedAtMillis === cursorMillis ? null : {
+			fromMillis: cursorMillis,
+			toMillis: intendedAtMillis
+		}
+	});
+};
+const scheduleResumeCursor = (timing, existingCursor, nowMillis) => {
+	if (timing._tag === "At") return Result.succeed(existingCursor);
+	return scheduleNextAfter(timing, nowMillis);
+};
+//#endregion
+//#region src/durable/Scheduling.ts
+var Scheduling_exports = /* @__PURE__ */ __exportAll({
+	ScheduleDriver: () => ScheduleDriver,
+	ScheduleWakeNoop: () => ScheduleWakeNoop,
+	Scheduling: () => Scheduling
+});
+const equivalentDefinitions = Schema.toEquivalence(DefinitionDigests);
+const equivalentInput = Schema.toEquivalence(PersistedJson);
+const keyOf = (scope, scheduleId) => ({
+	owner: scope.owner,
+	scheduleId
+});
+const notFound = (key) => ScheduleNotFound.make({ key });
+const asSnapshot = (record, observedAtMillis) => {
+	const intendedAtMillis = record.pending?.envelope.intendedAtMillis ?? record.nextAtMillis;
+	return {
+		owner: record.owner,
+		scheduleId: record.scheduleId,
+		createdAtMillis: record.createdAtMillis,
+		updatedAtMillis: record.updatedAtMillis,
+		configurationRevision: record.configurationRevision,
+		configuration: {
+			timing: record.configuration.timing,
+			destination: record.configuration.destination,
+			deliveryPrincipal: record.configuration.deliveryPrincipal,
+			...record.configuration.admissionGroup === void 0 ? {} : { admissionGroup: record.configuration.admissionGroup },
+			...record.configuration.admissionFence === void 0 ? {} : { admissionFence: record.configuration.admissionFence },
+			agentId: record.configuration.agentId
+		},
+		state: record.state,
+		nextAtMillis: record.nextAtMillis,
+		pending: record.pending === null ? null : {
+			intendedAtMillis: record.pending.envelope.intendedAtMillis,
+			preparedAtMillis: record.pending.envelope.preparedAtMillis,
+			configurationRevision: record.pending.envelope.configurationRevision,
+			occurrenceId: record.pending.envelope.occurrenceId,
+			retry: record.pending.retry
+		},
+		lastReceipt: record.lastReceipt,
+		lastRefusal: record.lastRefusal,
+		lastSkippedRange: record.lastSkippedRange,
+		observedAtMillis,
+		pendingAgeMillis: record.pending === null ? null : Math.max(0, observedAtMillis - record.pending.envelope.preparedAtMillis),
+		latenessMillis: intendedAtMillis === null ? 0 : Math.max(0, observedAtMillis - intendedAtMillis)
+	};
+};
+const inputByteLength = (input) => utf8ByteLength(JSON.stringify(input));
+const currentMillis = DateTime.now.pipe(Effect.map(DateTime.toEpochMillis));
+const validateRequestedFields = Effect.fn("Scheduling.validateRequestedFields")(function* (options) {
+	yield* Schema.encodeEffect(ScheduleTimingRequest)(options.timing).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid timing request" })));
+	yield* Schema.encodeEffect(ScheduleDestination)(options.destination).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid destination" })));
+	yield* Schema.encodeEffect(DefinitionDigests)(options.definitions).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid definition digests" })));
+});
+const resolveInput = Effect.fn("Scheduling.resolveInput")(function* (agent, input, maximumBytes) {
+	const encoded = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Unable to encode Agent input" })));
+	const payload = yield* Schema.decodeUnknownEffect(PersistedJson)(encoded).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Agent input does not satisfy the canonical persistence bounds" })));
+	if (inputByteLength(payload) > maximumBytes) return yield* ScheduleValidationError.make({ message: `Encoded Agent input exceeds the configured ${maximumBytes} byte limit` });
+	return {
+		payload,
+		digest: yield* digestJson(payload).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Unable to digest encoded Agent input" })))
+	};
+});
+const makeManagement = (limits) => Effect.gen(function* () {
+	const nowMillis = yield* currentMillis;
+	yield* Schema.decodeEffect(ScheduleInstant)(nowMillis + limits.recoveryPollMillis).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Scheduling recovery deadline exceeds the supported instant range" })));
+	const store = yield* ScheduleStore;
+	const authorizer = yield* ScheduleAuthorizer;
+	const wake = yield* ScheduleWake;
+	const crypto = yield* Crypto.Crypto;
+	const withCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
+	const fingerprint = Effect.fn("Scheduling.fingerprint")(function* (agentId, inputDigest, options) {
+		const timing = yield* Schema.encodeEffect(ScheduleTimingRequest)(options.timing).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid timing request" })));
+		const destination = yield* Schema.encodeEffect(ScheduleDestination)(options.destination).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid destination" })));
+		const definitions = yield* Schema.encodeEffect(DefinitionDigests)(options.definitions).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid definition digests" })));
+		return yield* withCrypto(digestJson({
+			schemaVersion: 1,
+			owner: options.scope.owner,
+			scheduleId: options.scheduleId,
+			registeringPrincipal: options.scope.principal,
+			deliveryPrincipal: options.deliveryPrincipal,
+			...options.admissionGroup === void 0 ? {} : { admissionGroup: options.admissionGroup },
+			...options.admissionFence === void 0 ? {} : { admissionFence: options.admissionFence },
+			agentId,
+			definitions,
+			destination,
+			timing,
+			inputDigest
+		})).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Unable to digest Schedule registration" })));
+	});
+	const configuration = (agentId, payload, inputDigest, options, timing) => ({
+		timing,
+		destination: options.destination,
+		deliveryPrincipal: options.deliveryPrincipal,
+		...options.admissionGroup === void 0 ? {} : { admissionGroup: options.admissionGroup },
+		...options.admissionFence === void 0 ? {} : { admissionFence: options.admissionFence },
+		agentId,
+		definitions: options.definitions,
+		input: payload,
+		inputDigest
+	});
+	const create = Effect.fn("Scheduling.create")(function* (agent, input, options) {
+		const nowMillis = yield* currentMillis;
+		const resolvedInput = yield* resolveInput(agent, input, limits.maxInputBytes).pipe(Effect.provideService(Crypto.Crypto, crypto));
+		const creationFingerprint = yield* fingerprint(agent.definition.id, resolvedInput.digest, options);
+		const key = keyOf(options.scope, options.scheduleId);
+		yield* authorizer.manage({
+			operation: "create",
+			scope: options.scope,
+			scheduleId: options.scheduleId
+		});
+		const existing = yield* store.get(key);
+		if (existing !== null) {
+			if (existing.creationFingerprint !== creationFingerprint) return yield* ScheduleConflict.make({
+				reason: "creation",
+				key
+			});
+			yield* authorizer.manage({
+				operation: "create",
+				scope: options.scope,
+				scheduleId: options.scheduleId,
+				configuration: existing.configuration
+			});
+			return asSnapshot(existing, nowMillis);
+		}
+		const timing = yield* Effect.fromResult(normalizeScheduleTiming(options.timing, nowMillis, limits.minIntervalMillis));
+		const nextAtMillis = yield* Effect.fromResult(scheduleInitialCursor(timing, nowMillis));
+		if (nextAtMillis === null) return yield* ScheduleValidationError.make({ message: "Timing has no next occurrence" });
+		const nextConfiguration = configuration(agent.definition.id, resolvedInput.payload, resolvedInput.digest, options, timing);
+		yield* authorizer.manage({
+			operation: "create",
+			scope: options.scope,
+			scheduleId: options.scheduleId,
+			configuration: nextConfiguration
+		});
+		const record = {
+			schemaVersion: 1,
+			owner: options.scope.owner,
+			scheduleId: options.scheduleId,
+			creationFingerprint,
+			createdBy: options.scope.principal,
+			createdAtMillis: nowMillis,
+			updatedAtMillis: nowMillis,
+			configurationRevision: 1,
+			version: 1,
+			configuration: nextConfiguration,
+			state: "active",
+			nextAtMillis,
+			pending: null,
+			lastReceipt: null,
+			lastRefusal: null,
+			lastSkippedRange: null
+		};
+		const inserted = yield* store.insert(record, limits.maxSchedulesPerOwner);
+		yield* wake.notify;
+		return asSnapshot(inserted, nowMillis);
+	});
+	const update = Effect.fn("Scheduling.update")(function* (agent, input, options) {
+		const nowMillis = yield* currentMillis;
+		const key = keyOf(options.scope, options.scheduleId);
+		yield* authorizer.manage({
+			operation: "update",
+			scope: options.scope,
+			scheduleId: options.scheduleId
+		});
+		yield* validateRequestedFields(options);
+		const existing = yield* store.get(key);
+		if (existing === null) return yield* notFound(key);
+		if (existing.configurationRevision !== options.expectedRevision) return yield* ScheduleConflict.make({
+			reason: "revision",
+			key
+		});
+		const resolvedInput = yield* resolveInput(agent, input, limits.maxInputBytes).pipe(Effect.provideService(Crypto.Crypto, crypto));
+		const timingRequest = options.timing._tag === "Interval" && options.timing.anchorMillis === void 0 && existing.configuration.timing._tag === "Interval" && existing.configuration.timing.everyMillis === options.timing.everyMillis ? {
+			...options.timing,
+			anchorMillis: existing.configuration.timing.anchorMillis
+		} : options.timing;
+		const timing = yield* Effect.fromResult(normalizeScheduleTiming(timingRequest, nowMillis, limits.minIntervalMillis));
+		const nextAtMillis = timing._tag === "At" ? timing.atMillis : yield* Effect.fromResult(scheduleNextAfter(timing, nowMillis));
+		if (nextAtMillis === null) return yield* ScheduleValidationError.make({ message: "Timing has no next occurrence" });
+		const nextConfiguration = configuration(agent.definition.id, resolvedInput.payload, resolvedInput.digest, options, timing);
+		yield* authorizer.manage({
+			operation: "update",
+			scope: options.scope,
+			scheduleId: options.scheduleId,
+			configuration: nextConfiguration
+		});
+		const changed = yield* store.change(key, {
+			_tag: "Update",
+			expectedRevision: options.expectedRevision,
+			configuration: nextConfiguration,
+			nextAtMillis,
+			nowMillis
+		}, limits.maxSchedulesPerOwner);
+		yield* wake.notify;
+		return asSnapshot(changed, nowMillis);
+	});
+	const get = Effect.fn("Scheduling.get")(function* (scope, scheduleId) {
+		yield* authorizer.manage({
+			operation: "get",
+			scope,
+			scheduleId
+		});
+		const key = keyOf(scope, scheduleId);
+		const record = yield* store.get(key);
+		if (record === null) return yield* notFound(key);
+		return asSnapshot(record, yield* currentMillis);
+	});
+	const list = Effect.fn("Scheduling.list")(function* (scope, options = {}) {
+		yield* authorizer.manage({
+			operation: "list",
+			scope
+		});
+		const limit = options.limit ?? 50;
+		if (!Number.isInteger(limit) || limit < 1 || limit > 100) return yield* ScheduleValidationError.make({ message: "Schedule page limit must be an integer from 1 through 100" });
+		const page = yield* store.list({
+			owner: scope.owner,
+			...options.after === void 0 ? {} : { after: options.after },
+			limit
+		});
+		const nowMillis = yield* currentMillis;
+		return {
+			items: page.items.map((record) => asSnapshot(record, nowMillis)),
+			next: page.next
+		};
+	});
+	const control = Effect.fn("Scheduling.control")(function* (operation, scope, scheduleId, expectedRevision) {
+		yield* authorizer.manage({
+			operation,
+			scope,
+			scheduleId
+		});
+		const key = keyOf(scope, scheduleId);
+		const attempt = () => Effect.suspend(() => Effect.gen(function* () {
+			const record = yield* store.get(key);
+			if (record === null) return yield* notFound(key);
+			if (record.configurationRevision !== expectedRevision) return yield* ScheduleConflict.make({
+				reason: "revision",
+				key
+			});
+			if (operation === "resume" && record.state === "active") return record;
+			const nowMillis = yield* currentMillis;
+			const nextAtMillis = operation === "resume" ? yield* Effect.fromResult(scheduleResumeCursor(record.configuration.timing, record.nextAtMillis, nowMillis)) : operation === "cancel" ? null : record.nextAtMillis;
+			const skippedRange = operation === "resume" && record.configuration.timing._tag !== "At" && record.nextAtMillis !== null && nextAtMillis !== null && nextAtMillis > record.nextAtMillis ? {
+				fromMillis: record.nextAtMillis,
+				toMillis: nextAtMillis
+			} : null;
+			return yield* store.change(key, {
+				_tag: "Control",
+				expectedRevision,
+				expectedVersion: record.version,
+				action: operation,
+				nextAtMillis,
+				nowMillis,
+				skippedRange
+			}, limits.maxSchedulesPerOwner).pipe(Effect.catchTag("ScheduleConflict", (error) => error.reason === "revision" ? attempt() : Effect.fail(error)));
+		}));
+		const changed = yield* attempt();
+		yield* wake.notify;
+		return asSnapshot(changed, yield* currentMillis);
+	});
+	const recover = Effect.fn("Scheduling.recover")(function* (scope, scheduleId, expectedRevision, expectedGeneration) {
+		yield* authorizer.manage({
+			operation: "recover",
+			scope,
+			scheduleId
+		});
+		const key = keyOf(scope, scheduleId);
+		const record = yield* store.get(key);
+		if (record === null) return yield* notFound(key);
+		if (record.configurationRevision !== expectedRevision) return yield* ScheduleConflict.make({
+			reason: "revision",
+			key
+		});
+		const time = yield* currentMillis;
+		if (record.pending === null) return asSnapshot(record, time);
+		const recovered = yield* store.change(key, {
+			_tag: "Recover",
+			expectedGeneration,
+			expectedRevision,
+			occurrenceId: record.pending.envelope.occurrenceId,
+			nowMillis: time
+		});
+		yield* wake.notify;
+		return asSnapshot(recovered, time);
+	});
+	return Scheduling.of({
+		recover,
+		create,
+		update,
+		get,
+		list,
+		pause: (scope, id, revision) => control("pause", scope, id, revision),
+		resume: (scope, id, revision) => control("resume", scope, id, revision),
+		cancel: (scope, id, revision) => control("cancel", scope, id, revision)
+	});
+});
+const makeDriver = (limits) => Effect.gen(function* () {
+	const store = yield* ScheduleStore;
+	const authorizer = yield* ScheduleAuthorizer;
+	const admission = yield* ScheduledInputAdmission;
+	const failpoint = yield* ScheduleFailpoint;
+	const crypto = yield* Crypto.Crypto;
+	const admissionSemaphore = yield* Semaphore.make(limits.admissionConcurrency);
+	const withCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
+	const retry = Effect.fn("Scheduling.retry")(function* (key, record, reason, nowMillis) {
+		if (record.pending === null) return record;
+		const current = record.pending.retry;
+		const delay = Math.min(limits.retryBaseMillis * 2 ** Math.min(current.attempts, 52), limits.retryMaxMillis);
+		return yield* store.change(key, {
+			_tag: "Retry",
+			occurrenceId: record.pending.envelope.occurrenceId,
+			retry: {
+				generation: current.generation,
+				attempts: current.attempts + 1,
+				automaticAttempts: current.automaticAttempts + 1,
+				parked: current.automaticAttempts + 1 >= (limits.maxAutomaticAttempts ?? 8),
+				nextAttemptAtMillis: Math.min(nowMillis + delay, 864e13),
+				lastAttemptAtMillis: nowMillis,
+				lastFailure: reason
+			},
+			nowMillis
+		});
+	});
+	const verifyPending = Effect.fn("Scheduling.verifyPending")(function* (key, record) {
+		const pending = record.pending;
+		if (pending === null) return;
+		const envelope = pending.envelope;
+		const occurrenceId = yield* withCrypto(digestJson({
+			schemaVersion: 1,
+			owner: envelope.owner,
+			scheduleId: envelope.scheduleId,
+			configurationRevision: envelope.configurationRevision,
+			intendedAtMillis: envelope.intendedAtMillis
+		})).pipe(Effect.mapError(() => corrupt("process")));
+		const usesCurrentConfiguration = envelope.configurationRevision === record.configurationRevision;
+		const expectedThreadId = usesCurrentConfiguration ? record.configuration.destination._tag === "ExistingThread" ? record.configuration.destination.threadId : Schema.decodeSync(ThreadId)(`schedule-thread:${envelope.occurrenceId}`) : null;
+		const expectedAdmissionKey = Schema.decodeSync(IdempotencyKey)(`schedule-occurrence:${envelope.occurrenceId}`);
+		const digest = yield* withCrypto(digestJson(envelope.input)).pipe(Effect.mapError(() => corrupt("process")));
+		if (envelope.schemaVersion !== 1 || envelope.owner.tenantId !== key.owner.tenantId || envelope.owner.ownerId !== key.owner.ownerId || envelope.scheduleId !== key.scheduleId || envelope.configurationRevision > record.configurationRevision || envelope.occurrenceId !== occurrenceId || usesCurrentConfiguration && (envelope.deliveryPrincipal !== record.configuration.deliveryPrincipal || envelope.agentId !== record.configuration.agentId || !equivalentDefinitions(envelope.definitions, record.configuration.definitions) || !equivalentInput(envelope.input, record.configuration.input) || envelope.inputDigest !== record.configuration.inputDigest) || envelope.inputDigest !== digest || expectedThreadId !== null && envelope.threadId !== expectedThreadId || envelope.admissionKey !== expectedAdmissionKey) return yield* corrupt("process");
+	});
+	const deliverPending = Effect.fn("Scheduling.deliverPending")(function* (key, record, nowMillis) {
+		if (record.pending === null || record.pending.retry.parked === true || record.pending.retry.nextAttemptAtMillis > nowMillis) return record;
+		yield* verifyPending(key, record);
+		const envelope = record.pending.envelope;
+		const outcome = yield* admissionSemaphore.withPermit(admitPreparedInput(admission.submit(envelope), limits.admissionTimeoutMillis).pipe(Effect.tap((outcome) => outcome._tag === "Receipt" ? failpoint.hit("schedule:admission:after") : Effect.void)));
+		const completedAtMillis = yield* currentMillis;
+		if (outcome._tag === "Receipt") {
+			if (outcome.receipt.threadId !== envelope.threadId) return yield* corrupt("admission");
+			return yield* store.change(key, {
+				_tag: "Complete",
+				occurrenceId: envelope.occurrenceId,
+				receipt: outcome.receipt,
+				nowMillis: completedAtMillis
+			}).pipe(Effect.catchTag("ScheduleStorageError", (error) => error.reason === "unavailable" ? retry(key, record, "storage", completedAtMillis) : Effect.fail(error)));
+		}
+		if (outcome._tag === "Refused") {
+			const refusal = {
+				atMillis: completedAtMillis,
+				intendedAtMillis: envelope.intendedAtMillis,
+				occurrenceId: envelope.occurrenceId,
+				phase: "admission",
+				code: outcome.error.code
+			};
+			return yield* store.change(key, {
+				_tag: "Refuse",
+				occurrenceId: envelope.occurrenceId,
+				refusal,
+				nowMillis: completedAtMillis
+			}).pipe(Effect.catchTag("ScheduleStorageError", (error) => error.reason === "unavailable" ? retry(key, record, "storage", completedAtMillis) : Effect.fail(error)));
+		}
+		return yield* retry(key, record, outcome.reason, completedAtMillis);
+	});
+	const processRecord = Effect.fn("Scheduling.processRecord")(function* (key, initial, nowMillis) {
+		if (initial.pending !== null) return yield* deliverPending(key, initial, nowMillis);
+		if (initial.state !== "active" || initial.nextAtMillis === null || initial.nextAtMillis > nowMillis) return initial;
+		if ((yield* withCrypto(digestJson(initial.configuration.input)).pipe(Effect.mapError(() => ScheduleStorageError.make({
+			operation: "prepare",
+			reason: "unavailable"
+		})))) !== initial.configuration.inputDigest) return yield* corrupt("prepare");
+		const due = yield* Effect.fromResult(scheduleDueOccurrence(initial.configuration.timing, initial.nextAtMillis, nowMillis));
+		if (due === null) return initial;
+		const occurrenceId = yield* withCrypto(digestJson({
+			schemaVersion: 1,
+			owner: initial.owner,
+			scheduleId: initial.scheduleId,
+			configurationRevision: initial.configurationRevision,
+			intendedAtMillis: due.intendedAtMillis
+		})).pipe(Effect.mapError(() => corrupt("prepare")));
+		const occurrence = {
+			key,
+			configurationRevision: initial.configurationRevision,
+			configuration: initial.configuration,
+			intendedAtMillis: due.intendedAtMillis,
+			occurrenceId
+		};
+		const authorization = yield* authorizer.prepare(occurrence).pipe(Effect.result);
+		if (Result.isFailure(authorization)) {
+			if (authorization.failure._tag === "ScheduleStorageError") return yield* authorization.failure;
+			return yield* store.change(key, {
+				_tag: "DenyPreparation",
+				expectedRevision: initial.configurationRevision,
+				expectedCursor: initial.nextAtMillis,
+				refusal: {
+					atMillis: nowMillis,
+					intendedAtMillis: due.intendedAtMillis,
+					occurrenceId,
+					phase: "preparation",
+					code: authorization.failure.code
+				},
+				nowMillis
+			});
+		}
+		const threadId = initial.configuration.destination._tag === "ExistingThread" ? initial.configuration.destination.threadId : Schema.decodeSync(ThreadId)(`schedule-thread:${occurrenceId}`);
+		const admissionKey = Schema.decodeSync(IdempotencyKey)(`schedule-occurrence:${occurrenceId}`);
+		const prepared = yield* store.change(key, {
+			_tag: "Prepare",
+			expectedRevision: initial.configurationRevision,
+			expectedCursor: initial.nextAtMillis,
+			envelope: {
+				schemaVersion: 1,
+				owner: initial.owner,
+				scheduleId: initial.scheduleId,
+				configurationRevision: initial.configurationRevision,
+				intendedAtMillis: due.intendedAtMillis,
+				preparedAtMillis: nowMillis,
+				occurrenceId,
+				threadId,
+				deliveryPrincipal: initial.configuration.deliveryPrincipal,
+				...initial.configuration.admissionGroup === void 0 ? {} : { admissionGroup: initial.configuration.admissionGroup },
+				...initial.configuration.admissionFence === void 0 ? {} : { admissionFence: initial.configuration.admissionFence },
+				agentId: initial.configuration.agentId,
+				definitions: initial.configuration.definitions,
+				input: initial.configuration.input,
+				inputDigest: initial.configuration.inputDigest,
+				admissionKey,
+				authorization: authorization.success
+			},
+			nextAtMillis: due.nextAtMillis,
+			skippedRange: due.skippedRange,
+			nowMillis
+		});
+		return yield* deliverPending(key, prepared, nowMillis);
+	});
+	const process = Effect.fn("Scheduling.process")(function* (key) {
+		const nowMillis = yield* currentMillis;
+		const record = yield* store.get(key);
+		if (record === null) return yield* notFound(key);
+		return yield* processRecord(key, record, nowMillis).pipe(Effect.catchTag("ScheduleConflict", () => store.get(key).pipe(Effect.flatMap((current) => current === null ? Effect.fail(notFound(key)) : processRecord(key, current, nowMillis)))));
+	});
+	const runDue = Effect.fn("ScheduleDriver.runDue")(function* (owner) {
+		const nowMillis = yield* currentMillis;
+		let after;
+		let processed = 0;
+		let failed = 0;
+		while (true) {
+			const due = yield* store.due(nowMillis, limits.dueBatchSize, owner, after);
+			if (due.length === 0) break;
+			yield* Effect.forEach(due, (key) => process(key).pipe(Effect.matchCauseEffect({
+				onSuccess: () => Effect.sync(() => {
+					processed += 1;
+				}),
+				onFailure: (cause) => Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.gen(function* () {
+					failed += 1;
+					yield* Effect.logWarning("Schedule processing failed").pipe(Effect.annotateLogs({ failureTag: Option.match(Cause.findErrorOption(cause), {
+						onNone: () => "Defect",
+						onSome: (error) => error._tag
+					}) }));
+				})
+			})), { concurrency: limits.admissionConcurrency });
+			after = due.at(-1);
+			if (due.length < limits.dueBatchSize) break;
+		}
+		return {
+			processed,
+			failed
+		};
+	});
+	return ScheduleDriver.of({
+		process,
+		runDue
+	});
+});
+const corrupt = (operation) => ScheduleStorageError.make({
+	operation,
+	reason: "corrupt"
+});
+const validateLimits = (limits) => Schema.decodeEffect(SchedulingLimits)(limits).pipe(Effect.mapError((error) => ScheduleValidationError.make({ message: `Invalid Scheduling limits: ${error.message}` })), Effect.filterOrFail((validated) => validated.retryBaseMillis <= validated.retryMaxMillis, () => ScheduleValidationError.make({ message: "Scheduling retryBaseMillis must not exceed retryMaxMillis" })));
+var Scheduling = class Scheduling extends Context.Service()("@effect-agent/thread/Scheduling") {
+	static layer(limits = defaultSchedulingLimits) {
+		return Layer.effect(Scheduling, validateLimits(limits).pipe(Effect.flatMap(makeManagement)));
+	}
+};
+const ScheduleWakeNoop = Layer.succeed(ScheduleWake, {
+	notify: Effect.void,
+	await: Effect.never
+});
+/** Privileged host capability. Never provide this service to management callers or model tools. */
+var ScheduleDriver = class ScheduleDriver extends Context.Service()("@effect-agent/thread/ScheduleDriver") {
+	static layer(limits = defaultSchedulingLimits) {
+		return Layer.effect(ScheduleDriver, validateLimits(limits).pipe(Effect.flatMap(makeDriver)));
+	}
+};
+//#endregion
+export { Scheduling_exports as i, ScheduleWakeNoop as n, Scheduling as r, ScheduleDriver as t };
+
+//# sourceMappingURL=Scheduling-C9aIP8zT.mjs.map