@deepseek-ai/dsh-schedule 0.1.1-rc.2 → 0.1.2-alpha.2

package/lib/index.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 //#region lib/types/domain.js
@@ -395,6 +396,44 @@ function dispatchedRecord(record, change) {
 	});
 }
 /**
+* Apply already-decoded Schedule changes to one complete fold value.
+*
+* This is the single transition authority shared by full-log replay and the
+* incremental Session projection. One mutable Map/Set pair spans the whole
+* batch; the returned arrays are materialized and frozen once.
+* @param folded - complete active records and used-id history before the changes.
+* @param changes - strictly decoded durable mutations in log order.
+* @returns the complete fold value after every mutation.
+*/
+function applyScheduleChanges(folded, changes) {
+	const active = new Map(folded.active.map((record) => [record.id, record]));
+	const seen = new Set(folded.seenIds);
+	for (const change of changes) 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])
+	});
+}
+/**
 * 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.
@@ -402,36 +441,14 @@ function dispatchedRecord(record, change) {
 */
 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])
+	const initial = Object.freeze({
+		active: Object.freeze([]),
+		seenIds: Object.freeze([])
 	});
+	const changes = function* () {
+		for (const event of events.slice(seedLength)) if (event.type === "schedule/change") yield decodeScheduleChange(event.data);
+	};
+	return applyScheduleChanges(initial, changes());
 }
 /**
 * Allocate the next readable id without reusing any prior session-local id.
@@ -571,6 +588,87 @@ function renderEveryReminderBatchFraming(reminders) {
 	].join("\n");
 }
 //#endregion
+//#region lib/types/projection.js
+/**
+* Strict Session projection of the Schedule domain's active reminder set.
+* @module @deepseek-ai/dsh-schedule/projection
+*/
+const scheduleId = z.unknown().transform((value, context) => {
+	try {
+		return decodeScheduleChange({
+			version: 1,
+			operation: "delete",
+			id: value
+		}).id;
+	} catch {
+		context.addIssue({
+			code: "custom",
+			message: "invalid Schedule id"
+		});
+		return z.NEVER;
+	}
+});
+const scheduleRecord = z.unknown().transform((value, context) => {
+	try {
+		return decodeScheduleChange({
+			version: 1,
+			operation: "create",
+			schedule: value
+		}).schedule;
+	} catch {
+		context.addIssue({
+			code: "custom",
+			message: "invalid Schedule record"
+		});
+		return z.NEVER;
+	}
+});
+const scheduleRecords = z.array(scheduleRecord);
+/** Projection definition sharing the Schedule domain's strict transition authority. */
+const scheduleProjectionDefinition = {
+	key: "schedule",
+	stateSchema: z.object({
+		seedLength: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		active: scheduleRecords,
+		seenIds: z.array(scheduleId)
+	}).strict().superRefine((state, context) => {
+		const seen = new Set(state.seenIds);
+		if (seen.size !== state.seenIds.length) context.addIssue({
+			code: "custom",
+			message: "seen Schedule ids must be unique"
+		});
+		const active = /* @__PURE__ */ new Set();
+		for (const record of state.active) {
+			if (!seen.has(record.id)) context.addIssue({
+				code: "custom",
+				message: "every active Schedule id must have been seen"
+			});
+			if (active.has(record.id)) context.addIssue({
+				code: "custom",
+				message: "active Schedule ids must be unique"
+			});
+			active.add(record.id);
+		}
+	}),
+	init: (header) => ({
+		seedLength: header.seedLength ?? 0,
+		active: [],
+		seenIds: []
+	}),
+	apply: (state, event) => {
+		if (event.seq < state.seedLength || event.type !== "schedule/change") return state;
+		return {
+			seedLength: state.seedLength,
+			...applyScheduleChanges(state, [decodeScheduleChange(event.data)])
+		};
+	},
+	wire: {
+		viewSchema: scheduleRecords,
+		view: (state) => state.active
+	},
+	stateVersion: 1
+};
+//#endregion
 //#region lib/types/persistence.js
 /** Schedule-owned use of the shared session durability barrier. */
 /** Failure to prove that the current live prefix reached a persistence listener. */
@@ -1350,6 +1448,9 @@ const inject = [
 ];
 /** Install Schedule only for root agents published after this plugin loads. */
 function apply(ctx) {
+	ctx.inject(["sessionProjections"], (projectionCtx) => {
+		projectionCtx.sessionProjections.register(scheduleProjectionDefinition);
+	});
 	const runtimes = /* @__PURE__ */ new Map();
 	let stopping = false;
 	ctx.effect(() => {

package/lib/invariant.js

@@ -209,6 +209,44 @@ function dispatchedRecord(record, change) {
 	});
 }
 /**
+* Apply already-decoded Schedule changes to one complete fold value.
+*
+* This is the single transition authority shared by full-log replay and the
+* incremental Session projection. One mutable Map/Set pair spans the whole
+* batch; the returned arrays are materialized and frozen once.
+* @param folded - complete active records and used-id history before the changes.
+* @param changes - strictly decoded durable mutations in log order.
+* @returns the complete fold value after every mutation.
+*/
+function applyScheduleChanges(folded, changes) {
+	const active = new Map(folded.active.map((record) => [record.id, record]));
+	const seen = new Set(folded.seenIds);
+	for (const change of changes) 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])
+	});
+}
+/**
 * 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.
@@ -216,36 +254,14 @@ function dispatchedRecord(record, change) {
 */
 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])
+	const initial = Object.freeze({
+		active: Object.freeze([]),
+		seenIds: Object.freeze([])
 	});
+	const changes = function* () {
+		for (const event of events.slice(seedLength)) if (event.type === "schedule/change") yield decodeScheduleChange(event.data);
+	};
+	return applyScheduleChanges(initial, changes());
 }
 //#endregion
 //#region lib/types/invariant.js

package/lib/types/client.d.ts

@@ -0,0 +1,3 @@
+/** Browser-safe Schedule vocabulary. @module @deepseek-ai/dsh-schedule/client */
+export type * from './types.ts';
+//# sourceMappingURL=client.d.ts.map

package/lib/types/client.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.js.map

package/lib/types/domain.d.ts

@@ -69,6 +69,17 @@ export declare function decodeScheduleChange(value: unknown): ScheduleChange;
  * @returns The latest due occurrence and first strictly future target, if representable.
  */
 export declare function resolveEveryOccurrence(record: EveryScheduleRecord, acceptedAt: number): EveryOccurrence;
+/**
+ * Apply already-decoded Schedule changes to one complete fold value.
+ *
+ * This is the single transition authority shared by full-log replay and the
+ * incremental Session projection. One mutable Map/Set pair spans the whole
+ * batch; the returned arrays are materialized and frozen once.
+ * @param folded - complete active records and used-id history before the changes.
+ * @param changes - strictly decoded durable mutations in log order.
+ * @returns the complete fold value after every mutation.
+ */
+export declare function applyScheduleChanges(folded: FoldedSchedules, changes: Iterable<ScheduleChange>): FoldedSchedules;
 /**
  * Fold the package-owned stream after the durable fork seed boundary.
  * @param events - Complete ordered session log or candidate-extended log.