@deepseek-ai/dsh-schedule 0.0.1-rc.3

package/lib/invariant.js

@@ -0,0 +1,291 @@
+const MIN_FOUR_DIGIT_YEAR_MS = Date.parse("0001-01-01T00:00:00.000Z");
+const MAX_FOUR_DIGIT_YEAR_MS = Date.parse("9999-12-31T23:59:59.999Z");
+const UTC_INSTANT = /^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d\.\d{3}Z$/;
+new RegExp(String.raw`^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})` + String.raw`T(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2})` + String.raw`(?:\.(?<fraction>\d{1,3}))?(?<zone>Z|(?<sign>[+-])` + String.raw`(?<offsetHour>\d{2}):(?<offsetMinute>\d{2}))$`);
+/** Error from malformed or transition-invalid durable Schedule data. */
+var ScheduleLogError = class extends Error {
+	/** Stable machine-readable error code. */
+	code = "corrupt_schedule_log";
+	/**
+	* Construct a durable-log failure.
+	* @param message - Package-specific violated invariant.
+	*/
+	constructor(message) {
+		super(message);
+		this.name = "ScheduleLogError";
+	}
+};
+/**
+* Brand a raw session-local id without changing its runtime value.
+* @param value - Raw session-local id.
+* @returns The same string with the Schedule brand.
+*/
+function ScheduleId(value) {
+	return value;
+}
+/** Whether an unknown value is a non-array object. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Require exactly the named durable object keys. */
+function hasExactKeys(value, expected) {
+	const keys = Object.keys(value).sort();
+	const wanted = [...expected].sort();
+	return keys.length === wanted.length && keys.every((key, index) => key === wanted[index]);
+}
+/** Validate one stable session-local id at the durable boundary. */
+function decodeId(value) {
+	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) throw new ScheduleLogError("schedule id must be a non-empty string without surrounding whitespace");
+	return ScheduleId(value);
+}
+/** Validate one canonical four-digit-year UTC instant. */
+function decodeInstant(value) {
+	if (typeof value !== "string" || !UTC_INSTANT.test(value)) throw new ScheduleLogError("scheduledAt must be a canonical four-digit-year RFC 3339 UTC instant");
+	const epoch = Date.parse(value);
+	if (!Number.isFinite(epoch) || new Date(epoch).toISOString() !== value) throw new ScheduleLogError("scheduledAt is not a real UTC calendar instant");
+	return value;
+}
+/** Decode the exact v1 after record shape. */
+function decodeAfterRecord(value) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"id",
+		"kind",
+		"prompt",
+		"afterSeconds",
+		"scheduledAt"
+	])) throw new ScheduleLogError("after schedule must contain exactly id, kind, prompt, afterSeconds, and scheduledAt");
+	const prompt = value["prompt"];
+	if (typeof prompt !== "string" || prompt.length === 0 || prompt.trim() !== prompt) throw new ScheduleLogError("after prompt must be non-empty and already trimmed");
+	const afterSeconds = value["afterSeconds"];
+	if (!Number.isSafeInteger(afterSeconds) || afterSeconds <= 0) throw new ScheduleLogError("afterSeconds must be a positive safe integer");
+	return Object.freeze({
+		id: decodeId(value["id"]),
+		kind: "after",
+		prompt,
+		afterSeconds,
+		scheduledAt: decodeInstant(value["scheduledAt"])
+	});
+}
+/** Decode the exact v1 absolute one-shot record shape. */
+function decodeAtRecord(value) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"id",
+		"kind",
+		"prompt",
+		"scheduledAt"
+	])) throw new ScheduleLogError("at schedule must contain exactly id, kind, prompt, and scheduledAt");
+	const prompt = value["prompt"];
+	if (typeof prompt !== "string" || prompt.length === 0 || prompt.trim() !== prompt) throw new ScheduleLogError("at prompt must be non-empty and already trimmed");
+	return Object.freeze({
+		id: decodeId(value["id"]),
+		kind: "at",
+		prompt,
+		scheduledAt: decodeInstant(value["scheduledAt"])
+	});
+}
+/** Decode the exact v1 fixed-rate record shape. */
+function decodeEveryRecord(value) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"id",
+		"kind",
+		"prompt",
+		"everySeconds",
+		"scheduledAt"
+	])) throw new ScheduleLogError("every schedule must contain exactly id, kind, prompt, everySeconds, and scheduledAt");
+	const prompt = value["prompt"];
+	if (typeof prompt !== "string" || prompt.length === 0 || prompt.trim() !== prompt) throw new ScheduleLogError("every prompt must be non-empty and already trimmed");
+	const everySeconds = value["everySeconds"];
+	const interval = typeof everySeconds === "number" ? everySeconds * 1e3 : NaN;
+	if (!Number.isSafeInteger(everySeconds) || everySeconds < 300 || !Number.isSafeInteger(interval)) throw new ScheduleLogError(`everySeconds must be a safe integer of at least 300`);
+	return Object.freeze({
+		id: decodeId(value["id"]),
+		kind: "every",
+		prompt,
+		everySeconds,
+		scheduledAt: decodeInstant(value["scheduledAt"])
+	});
+}
+/** Decode one current durable record variant by its exact discriminator. */
+function decodeScheduleRecord(value) {
+	if (!isRecord(value)) throw new ScheduleLogError("schedule record must be an object");
+	switch (value["kind"]) {
+		case "after": return decodeAfterRecord(value);
+		case "at": return decodeAtRecord(value);
+		case "every": return decodeEveryRecord(value);
+		default: throw new ScheduleLogError("v1 schedule kind must be \"after\", \"at\", or \"every\"");
+	}
+}
+/**
+* Decode one strict version-1 `schedule/change` payload.
+* @param value - Untrusted durable JSON value.
+* @returns Detached, frozen Schedule change.
+*/
+function decodeScheduleChange(value) {
+	if (!isRecord(value)) throw new ScheduleLogError("schedule/change payload must be an object");
+	if (value["version"] !== 1) throw new ScheduleLogError("schedule/change version must be 1");
+	switch (value["operation"]) {
+		case "create":
+			if (!hasExactKeys(value, [
+				"version",
+				"operation",
+				"schedule"
+			])) throw new ScheduleLogError("schedule create must contain exactly version, operation, and schedule");
+			return Object.freeze({
+				version: 1,
+				operation: "create",
+				schedule: decodeScheduleRecord(value["schedule"])
+			});
+		case "delete":
+			if (!hasExactKeys(value, [
+				"version",
+				"operation",
+				"id"
+			])) throw new ScheduleLogError("schedule delete must contain exactly version, operation, and id");
+			return Object.freeze({
+				version: 1,
+				operation: "delete",
+				id: decodeId(value["id"])
+			});
+		case "dispatch":
+			if (hasExactKeys(value, [
+				"version",
+				"operation",
+				"id"
+			])) return Object.freeze({
+				version: 1,
+				operation: "dispatch",
+				id: decodeId(value["id"])
+			});
+			if (hasExactKeys(value, [
+				"version",
+				"operation",
+				"id",
+				"acceptedAt"
+			])) return Object.freeze({
+				version: 1,
+				operation: "dispatch",
+				id: decodeId(value["id"]),
+				acceptedAt: decodeInstant(value["acceptedAt"])
+			});
+			throw new ScheduleLogError("schedule dispatch must contain id and optional acceptedAt only");
+		default: throw new ScheduleLogError("schedule/change operation must be create, delete, or dispatch");
+	}
+}
+/**
+* Resolve one fixed-rate decision without enumerating missed occurrences.
+* @param record - Active record whose target is the earliest unaccepted occurrence.
+* @param acceptedAt - Wall-clock decision time in epoch milliseconds.
+* @returns The latest due occurrence and first strictly future target, if representable.
+*/
+function resolveEveryOccurrence(record, acceptedAt) {
+	const target = Date.parse(record.scheduledAt);
+	const interval = record.everySeconds * 1e3;
+	if (!Number.isSafeInteger(acceptedAt) || acceptedAt < MIN_FOUR_DIGIT_YEAR_MS || acceptedAt > MAX_FOUR_DIGIT_YEAR_MS) throw new ScheduleLogError("every acceptedAt must be a representable four-digit-year instant");
+	if (!Number.isSafeInteger(interval) || interval <= 0) throw new ScheduleLogError("every interval milliseconds must be a positive safe integer");
+	if (acceptedAt < target) throw new ScheduleLogError("every dispatch cannot precede the active scheduledAt");
+	const occurrence = target + Math.floor((acceptedAt - target) / interval) * interval;
+	/* v8 ignore next -- bounded operands and a quotient-derived product stay safe. */
+	if (!Number.isSafeInteger(occurrence) || occurrence < target || occurrence > acceptedAt) throw new ScheduleLogError("every occurrence arithmetic must stay within the accepted interval");
+	const occurrenceAt = new Date(occurrence).toISOString();
+	const next = occurrence + interval;
+	if (!Number.isSafeInteger(next) || next > MAX_FOUR_DIGIT_YEAR_MS) return Object.freeze({ occurrenceAt });
+	return Object.freeze({
+		occurrenceAt,
+		nextScheduledAt: new Date(next).toISOString()
+	});
+}
+/** Apply one decoded dispatch to its exact active record. */
+function dispatchedRecord(record, change) {
+	const hasAcceptedAt = "acceptedAt" in change;
+	if (record.kind !== "every") {
+		if (hasAcceptedAt) throw new ScheduleLogError("one-shot dispatch must not contain acceptedAt");
+		return;
+	}
+	if (!hasAcceptedAt) throw new ScheduleLogError("every dispatch must contain acceptedAt");
+	const occurrence = resolveEveryOccurrence(record, Date.parse(change.acceptedAt));
+	return occurrence.nextScheduledAt === void 0 ? void 0 : Object.freeze({
+		...record,
+		scheduledAt: occurrence.nextScheduledAt
+	});
+}
+/**
+* Fold the package-owned stream after the durable fork seed boundary.
+* @param events - Complete ordered session log or candidate-extended log.
+* @param seedLength - Inherited prefix length excluded from child ownership.
+* @returns Active records and all previously used ids.
+*/
+function foldScheduleEvents(events, seedLength = 0) {
+	if (!Number.isSafeInteger(seedLength) || seedLength < 0 || seedLength > events.length) throw new ScheduleLogError("schedule seedLength must be within the supplied event log");
+	const active = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const event of events.slice(seedLength)) {
+		if (event.type !== "schedule/change") continue;
+		const change = decodeScheduleChange(event.data);
+		switch (change.operation) {
+			case "create":
+				if (seen.has(change.schedule.id)) throw new ScheduleLogError(`schedule id ${JSON.stringify(change.schedule.id)} was reused`);
+				seen.add(change.schedule.id);
+				active.set(change.schedule.id, change.schedule);
+				break;
+			case "delete":
+				if (!active.delete(change.id)) throw new ScheduleLogError(`schedule delete targets inactive id ${JSON.stringify(change.id)}`);
+				break;
+			case "dispatch": {
+				const record = active.get(change.id);
+				if (record === void 0) throw new ScheduleLogError(`schedule dispatch targets inactive id ${JSON.stringify(change.id)}`);
+				const next = dispatchedRecord(record, change);
+				if (next === void 0) active.delete(change.id);
+				else active.set(change.id, next);
+				break;
+			}
+			/* v8 ignore next 3 -- decodeScheduleChange returns a closed operation union. */
+			default: throw new ScheduleLogError(`unknown decoded schedule change ${String(change)}`);
+		}
+	}
+	return Object.freeze({
+		active: Object.freeze([...active.values()]),
+		seenIds: Object.freeze([...seen])
+	});
+}
+//#endregion
+//#region lib/types/invariant.js
+/**
+* Package-owned strict Schedule stream invariant.
+* @module @deepseek-ai/dsh-schedule/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-schedule";
+/** Cordis invariant-companion plugin name. */
+const name = "tool-schedule-invariant";
+/** Service required before reserving this package's invariant ownership. */
+const inject = ["invariants"];
+/** Validate a complete exact-session stream under its fork suffix policy. */
+function validate(events, seedLength, fail) {
+	try {
+		foldScheduleEvents(events, seedLength);
+	} catch (error) {
+		/* v8 ignore next -- foldScheduleEvents normalizes every rejected stream to ScheduleLogError. */
+		if (!(error instanceof ScheduleLogError)) throw error;
+		fail(error.message);
+	}
+}
+/** Install replay and pre-append validation for the owned event stream. */
+const install = Object.assign((ctx, fail) => {
+	for (const session of ctx.sessions.list()) validate(session.events, session.header.seedLength ?? 0, fail);
+	ctx.on("session/created", (session) => {
+		validate(session.events, session.header.seedLength ?? 0, fail);
+	}, { global: true });
+	ctx.on("internal/dispatch", (_mode, eventName, args) => {
+		if (eventName !== "session/event") return;
+		const [session, event] = args;
+		if (event.type !== "schedule/change") return;
+		validate([...session.events, event], session.header.seedLength ?? 0, fail);
+	}, { global: true });
+}, { inject: ["sessions"] });
+/**
+* Register the package-owned invariant companion.
+* @param ctx - Cordis context carrying the invariant registry.
+* @returns Exact registration disposer after child setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/domain.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Strict Schedule decoding, replay, time validation, and framing.
+ * @module @deepseek-ai/dsh-schedule
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { AfterScheduleRecord, AtInput, AtScheduleRecord, EveryScheduleRecord, OneShotScheduleRecord, ScheduleChange, ScheduleId as ScheduleIdType, ScheduleRecord, ScheduleView } from './types.ts';
+/** Durable Schedule protocol version implemented by this package. */
+export declare const SCHEDULE_CHANGE_VERSION: 1;
+/** Fixed v1 lower bound for a fixed-rate reminder. */
+export declare const MIN_EVERY_INTERVAL_SECONDS = 300;
+/** Error from malformed or transition-invalid durable Schedule data. */
+export declare class ScheduleLogError extends Error {
+    /** Stable machine-readable error code. */
+    readonly code: "corrupt_schedule_log";
+    /**
+     * Construct a durable-log failure.
+     * @param message - Package-specific violated invariant.
+     */
+    constructor(message: string);
+}
+/** Error from a model-supplied Schedule rule that cannot become a record. */
+export declare class ScheduleInputError extends Error {
+    /** Stable public Schedule input code. */
+    readonly code: 'invalid_prompt' | 'invalid_rule' | 'invalid_time_zone' | 'not_future' | 'time_out_of_range' | 'frequency_too_high';
+    /**
+     * Construct a stable input failure.
+     * @param code - Public Schedule error discriminator.
+     * @param message - Stable public diagnostic.
+     * @param options - Optional contained implementation cause.
+     */
+    constructor(code: 'invalid_prompt' | 'invalid_rule' | 'invalid_time_zone' | 'not_future' | 'time_out_of_range' | 'frequency_too_high', message: string, options?: ErrorOptions);
+}
+/** Pure replay result, retaining active create order and every used id. */
+export interface FoldedSchedules {
+    /** Active records in their original create order. */
+    readonly active: readonly ScheduleRecord[];
+    /** Every id ever created in this session-local suffix. */
+    readonly seenIds: readonly ScheduleIdType[];
+}
+/** One latest-only fixed-rate decision derived without enumerating a backlog. */
+export interface EveryOccurrence {
+    /** Latest anchor-aligned occurrence due at the decision time. */
+    readonly occurrenceAt: string;
+    /** First anchor-aligned target after the decision, or exhaustion. */
+    readonly nextScheduledAt?: string;
+}
+/**
+ * Brand a raw session-local id without changing its runtime value.
+ * @param value - Raw session-local id.
+ * @returns The same string with the Schedule brand.
+ */
+export declare function ScheduleId(value: string): ScheduleIdType;
+/**
+ * Validate and canonicalize one raw IANA time-zone selector.
+ * @param value - Candidate `UTC` or IANA Area/Location name.
+ * @returns The runtime's canonical IANA name.
+ */
+export declare function canonicalizeTimeZone(value: string): string;
+/**
+ * Decode one strict version-1 `schedule/change` payload.
+ * @param value - Untrusted durable JSON value.
+ * @returns Detached, frozen Schedule change.
+ */
+export declare function decodeScheduleChange(value: unknown): ScheduleChange;
+/**
+ * Resolve one fixed-rate decision without enumerating missed occurrences.
+ * @param record - Active record whose target is the earliest unaccepted occurrence.
+ * @param acceptedAt - Wall-clock decision time in epoch milliseconds.
+ * @returns The latest due occurrence and first strictly future target, if representable.
+ */
+export declare function resolveEveryOccurrence(record: EveryScheduleRecord, acceptedAt: number): EveryOccurrence;
+/**
+ * Fold the package-owned stream after the durable fork seed boundary.
+ * @param events - Complete ordered session log or candidate-extended log.
+ * @param seedLength - Inherited prefix length excluded from child ownership.
+ * @returns Active records and all previously used ids.
+ */
+export declare function foldScheduleEvents(events: readonly SessionEvent[], seedLength?: number): FoldedSchedules;
+/**
+ * Allocate the next readable id without reusing any prior session-local id.
+ * @param folded - Fold containing every previously created id.
+ * @returns A fresh `schedule-N` identity.
+ */
+export declare function allocateScheduleId(folded: FoldedSchedules): ScheduleIdType;
+/**
+ * Validate a model after rule and compute its durable target.
+ * @param id - Already allocated session-local id.
+ * @param prompt - Reminder content supplied at creation.
+ * @param afterSeconds - Requested positive delay.
+ * @param now - Single creation-time wall-clock sample in epoch milliseconds.
+ * @returns Frozen durable after record.
+ */
+export declare function createAfterScheduleRecord(id: ScheduleIdType, prompt: string, afterSeconds: number, now: number): AfterScheduleRecord;
+/**
+ * Validate an absolute selector and compute its sole durable UTC target.
+ * @param id - Already allocated session-local id.
+ * @param prompt - Reminder content supplied at creation.
+ * @param at - Explicit-offset instant or structured local calendar value.
+ * @param now - Single creation-time wall-clock sample in epoch milliseconds.
+ * @returns Frozen durable absolute one-shot record.
+ */
+export declare function createAtScheduleRecord(id: ScheduleIdType, prompt: string, at: AtInput, now: number): AtScheduleRecord;
+/**
+ * Validate a fixed-rate selector and compute its first creation-aligned target.
+ * @param id - Already allocated session-local id.
+ * @param prompt - Reminder content supplied at creation.
+ * @param everySeconds - Requested fixed safe-integer interval.
+ * @param now - Single creation-time wall-clock sample in epoch milliseconds.
+ * @returns Frozen durable fixed-rate record.
+ */
+export declare function createEveryScheduleRecord(id: ScheduleIdType, prompt: string, everySeconds: number, now: number): EveryScheduleRecord;
+/**
+ * Derive one execution-local management view.
+ * @param record - Active durable record.
+ * @param now - Wall-clock sample used for its timing state.
+ * @returns Complete session-local view.
+ */
+export declare function scheduleView(record: ScheduleRecord, now: number): ScheduleView;
+/**
+ * Render the fixed injection-resistant model framing for a due reminder.
+ * @param record - Due active record.
+ * @returns Stable model-visible text with JSON-escaped dynamic fields.
+ */
+export declare function renderReminderFraming(record: OneShotScheduleRecord): string;
+/**
+ * Render one injection-resistant fixed-rate batch in target and create order.
+ * @param reminders - Complete admitted batch with one latest occurrence per record.
+ * @returns Stable model-visible text whose dynamic payload is canonical JSON.
+ */
+export declare function renderEveryReminderBatchFraming(reminders: readonly {
+    readonly record: EveryScheduleRecord;
+    readonly occurrenceAt: string;
+}[]): string;
+//# sourceMappingURL=domain.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agent-scoped durable one-shot and fixed-rate reminders over the session event log.
+ * @module @deepseek-ai/dsh-schedule
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export type * from './types.ts';
+export { SCHEDULE_CHANGE_VERSION, MIN_EVERY_INTERVAL_SECONDS, ScheduleId, ScheduleInputError, ScheduleLogError, allocateScheduleId, createAfterScheduleRecord, createAtScheduleRecord, createEveryScheduleRecord, decodeScheduleChange, foldScheduleEvents, renderReminderFraming, renderEveryReminderBatchFraming, resolveEveryOccurrence, scheduleView, } from './domain.ts';
+export { registerScheduleTools } from './tools.ts';
+/** Cordis function-plugin name. */
+export declare const name = "schedule";
+/** Services required before future root agents can receive Schedule. */
+export declare const inject: string[];
+/** Install Schedule only for root agents published after this plugin loads. */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned strict Schedule stream invariant.
+ * @module @deepseek-ai/dsh-schedule/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis invariant-companion plugin name. */
+export declare const name = "tool-schedule-invariant";
+/** Service required before reserving this package's invariant ownership. */
+export declare const inject: string[];
+/**
+ * Register the package-owned invariant companion.
+ * @param ctx - Cordis context carrying the invariant registry.
+ * @returns Exact registration disposer after child setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/persistence.d.ts

@@ -0,0 +1,19 @@
+/** Schedule-owned use of the shared session durability barrier. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Session } from '@deepseek-ai/dsh-session';
+/** Failure to prove that the current live prefix reached a persistence listener. */
+export declare class SchedulePersistenceError extends Error {
+    /**
+     * Construct a contained persistence failure.
+     * @param cause - Rejection returned by the shared barrier, when present.
+     */
+    constructor(cause?: unknown);
+}
+/**
+ * Require one successful shared persistence checkpoint.
+ * @param ctx - Context carrying the live session store.
+ * @param session - Exact live session to checkpoint.
+ * @returns After at least one listener explicitly acknowledges completed durability work.
+ */
+export declare function flushSchedulePersistence(ctx: Context, session: Session): Promise<void>;
+//# sourceMappingURL=persistence.d.ts.map

package/lib/types/runtime.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Disposable live timer projection for one exact root agent.
+ * @module @deepseek-ai/dsh-schedule
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+/** Largest delay that Node timers represent without clamping. */
+export declare const MAX_TIMER_DELAY_MS = 2147483647;
+/** One process-local, disposable projection of an exact agent's durable schedules. */
+export declare class ScheduleRuntime {
+    private readonly ctx;
+    private readonly agent;
+    private readonly stop;
+    private timer;
+    private idleWait;
+    private run;
+    private requested;
+    private stopping;
+    private faulted;
+    private disposal;
+    /**
+     * Construct an inactive runtime; {@link start} begins the first preflight.
+     * @param ctx - Global service context.
+     * @param agent - Exact live root agent.
+     */
+    constructor(ctx: Context, agent: Agent);
+    /** Begin the initial durability preflight and timer derivation. */
+    start(): void;
+    /** Recompute the live projection after a committed mutation or idle transition. */
+    requestDrive(): void;
+    /** Stop future work, cancel timers, and await every outstanding runtime promise. */
+    dispose(): Promise<void>;
+    /** Drain coalesced triggers serially. */
+    private runRequested;
+    /** Retire one exact run and honor a trigger that landed during its final microtask. */
+    private retire;
+    /** Whether this exact root lifecycle remains authoritative. */
+    private isLive;
+    /** Whether this runtime may start or continue Schedule work. */
+    private isRunnable;
+    /** Cancel the currently armed timer, if any. */
+    private clearTimer;
+    /** Arm one bounded timer segment; every wake rechecks the wall clock. */
+    private arm;
+    /** Await one public idle boundary without holding admission or creating a retry timer. */
+    private waitForIdle;
+    /** Fold the current exact runtime suffix and contain a corrupt durable stream. */
+    private readFolded;
+    /** Contain an invalid wall-clock decision without permanently faulting this runtime. */
+    private decide;
+    /** Preflight, fold, arm, or dispatch the next one-shot or fixed-rate batch. */
+    private driveOnce;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/lib/types/tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Agent-scoped Schedule management tools over the durable session fold.
+ * @module @deepseek-ai/dsh-schedule
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+/**
+ * Register all three Schedule tools in one exact agent scope.
+ * @param rootCtx - Global service context owning sessions and durability.
+ * @param toolCtx - Exact agent-scoped context receiving the definitions.
+ * @param agent - Exact live owner whose session the tools mutate.
+ * @param onDurableChange - Called after every successful preflight and again after a create or actual delete barrier succeeds.
+ * @returns Idempotent aggregate disposer for the three registrations.
+ */
+export declare function registerScheduleTools(rootCtx: Context, toolCtx: Context, agent: Agent, onDurableChange: () => void): () => void;
+//# sourceMappingURL=tools.d.ts.map

package/lib/types/transaction.d.ts

@@ -0,0 +1,10 @@
+/** Agent-scoped serialization for Schedule reads and durable mutations. */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+/**
+ * Run one complete Schedule transaction after its exact Agent's prior transaction.
+ * @param agent - Exact Schedule owner and serialization key.
+ * @param operation - Complete preflight, fold, mutation, and postflight operation.
+ * @returns The operation result after exclusive execution.
+ */
+export declare function runScheduleTransaction<T>(agent: Agent, operation: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=transaction.d.ts.map