@vitest-agent/sdk 1.3.4 → 2.0.0

package/schemas/ChannelEvent.js

@@ -12,8 +12,21 @@ import { Schema } from "effect";
 * behavior events are advisory and may be overwritten.
 */
 /** @public */
-const SessionOutcome = Schema.Literal("succeeded", "blocked", "abandoned");
-const PhaseLiteral = Schema.Literal("spike", "red", "red.triangulate", "green", "green.fake-it", "refactor", "extended-red", "green-without-red");
+const SessionOutcome = Schema.Literals([
+	"succeeded",
+	"blocked",
+	"abandoned"
+]);
+const PhaseLiteral = Schema.Literals([
+	"spike",
+	"red",
+	"red.triangulate",
+	"green",
+	"green.fake-it",
+	"refactor",
+	"extended-red",
+	"green-without-red"
+]);
 const GoalSummary = Schema.Struct({
 	id: Schema.Number,
 	ordinal: Schema.Number,
@@ -118,7 +131,21 @@ const SessionCompleteEvent = Schema.Struct({
 	outcome: SessionOutcome
 });
 /** @public */
-const ChannelEvent = Schema.Union(GoalsReadyEvent, GoalAddedEvent, GoalStartedEvent, GoalCompletedEvent, GoalAbandonedEvent, BehaviorsReadyEvent, BehaviorAddedEvent, BehaviorStartedEvent, PhaseTransitionEvent, BehaviorCompletedEvent, BehaviorAbandonedEvent, BlockedEvent, SessionCompleteEvent);
+const ChannelEvent = Schema.Union([
+	GoalsReadyEvent,
+	GoalAddedEvent,
+	GoalStartedEvent,
+	GoalCompletedEvent,
+	GoalAbandonedEvent,
+	BehaviorsReadyEvent,
+	BehaviorAddedEvent,
+	BehaviorStartedEvent,
+	PhaseTransitionEvent,
+	BehaviorCompletedEvent,
+	BehaviorAbandonedEvent,
+	BlockedEvent,
+	SessionCompleteEvent
+]);
 /**
 * Event types whose `goalId` and `sessionId` should be resolved
 * server-side from `behaviorId` (per spec: "not trusting the

package/schemas/Common.js

@@ -11,22 +11,41 @@ import { Schema } from "effect";
 * Possible states for an individual test case.
 * @public
 */
-const TestState = Schema.Literal("passed", "failed", "skipped", "pending").annotations({ identifier: "TestState" });
+const TestState = Schema.Literals([
+	"passed",
+	"failed",
+	"skipped",
+	"pending"
+]).annotate({ identifier: "TestState" });
 /**
 * Overall outcome of a test run.
 * @public
 */
-const TestRunReason = Schema.Literal("passed", "failed", "interrupted").annotations({ identifier: "TestRunReason" });
+const TestRunReason = Schema.Literals([
+	"passed",
+	"failed",
+	"interrupted"
+]).annotate({ identifier: "TestRunReason" });
 /**
 * Classification of a test's failure history across runs.
 * @public
 */
-const TestClassification = Schema.Literal("stable", "new-failure", "persistent", "flaky", "recovered").annotations({ identifier: "TestClassification" });
+const TestClassification = Schema.Literals([
+	"stable",
+	"new-failure",
+	"persistent",
+	"flaky",
+	"recovered"
+]).annotate({ identifier: "TestClassification" });
 /**
 * Console output verbosity mode for AgentReporter.
 * @public
 */
-const ConsoleOutputMode = Schema.Literal("failures", "full", "silent").annotations({ identifier: "ConsoleOutputMode" });
+const ConsoleOutputMode = Schema.Literals([
+	"failures",
+	"full",
+	"silent"
+]).annotate({ identifier: "ConsoleOutputMode" });
 /**
 * Console output choices per executor type.
 *
@@ -45,42 +64,85 @@ const ConsoleOutputMode = Schema.Literal("failures", "full", "silent").annotatio
 *   so the default for `ci` is `passthrough` until it lands.
 * @public
 */
-const HumanConsoleMode = Schema.Literal("passthrough", "silent", "stream", "agent").annotations({ identifier: "HumanConsoleMode" });
+const HumanConsoleMode = Schema.Literals([
+	"passthrough",
+	"silent",
+	"stream",
+	"agent"
+]).annotate({ identifier: "HumanConsoleMode" });
 /** @public */
-const AgentConsoleMode = Schema.Literal("passthrough", "silent", "agent").annotations({ identifier: "AgentConsoleMode" });
+const AgentConsoleMode = Schema.Literals([
+	"passthrough",
+	"silent",
+	"agent"
+]).annotate({ identifier: "AgentConsoleMode" });
 /** @public */
-const CiConsoleMode = Schema.Literal("passthrough", "silent", "ci-annotations").annotations({ identifier: "CiConsoleMode" });
+const CiConsoleMode = Schema.Literals([
+	"passthrough",
+	"silent",
+	"ci-annotations"
+]).annotate({ identifier: "CiConsoleMode" });
 /**
 * Union of every legal console-output value across the three executor slots.
 * Useful for type-narrowing in renderers that take the resolved value.
 * @public
 */
-const ConsoleMode = Schema.Union(HumanConsoleMode, AgentConsoleMode, CiConsoleMode).annotations({ identifier: "ConsoleMode" });
+const ConsoleMode = Schema.Union([
+	HumanConsoleMode,
+	AgentConsoleMode,
+	CiConsoleMode
+]).annotate({ identifier: "ConsoleMode" });
 /**
 * Supported package managers for run command generation.
 * @public
 */
-const PackageManager = Schema.Literal("pnpm", "npm", "yarn", "bun").annotations({ identifier: "PackageManager" });
+const PackageManager = Schema.Literals([
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun"
+]).annotate({ identifier: "PackageManager" });
 /**
 * Runtime environment where tests are being executed.
 * @public
 */
-const Environment = Schema.Literal("agent-shell", "terminal", "ci-github", "ci-generic").annotations({ identifier: "Environment" });
+const Environment = Schema.Literals([
+	"agent-shell",
+	"terminal",
+	"ci-github",
+	"ci-generic"
+]).annotate({ identifier: "Environment" });
 /**
 * Who or what is executing the test run.
 * @public
 */
-const Executor = Schema.Literal("human", "agent", "ci").annotations({ identifier: "Executor" });
+const Executor = Schema.Literals([
+	"human",
+	"agent",
+	"ci"
+]).annotate({ identifier: "Executor" });
 /**
 * Output format for the reporter pipeline.
 * @public
 */
-const OutputFormat = Schema.Literal("terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations").annotations({ identifier: "OutputFormat" });
+const OutputFormat = Schema.Literals([
+	"terminal",
+	"markdown",
+	"json",
+	"vitest-bypass",
+	"silent",
+	"ci-annotations"
+]).annotate({ identifier: "OutputFormat" });
 /**
 * Level of detail in reporter output.
 * @public
 */
-const DetailLevel = Schema.Literal("minimal", "neutral", "standard", "verbose").annotations({ identifier: "DetailLevel" });
+const DetailLevel = Schema.Literals([
+	"minimal",
+	"neutral",
+	"standard",
+	"verbose"
+]).annotate({ identifier: "DetailLevel" });
 /**
 * A single test or module error with optional stack trace, diff, and
 * structured assertion values.
@@ -99,7 +161,7 @@ const ReportError = Schema.Struct({
 	diff: Schema.optional(Schema.String),
 	expected: Schema.optional(Schema.String),
 	received: Schema.optional(Schema.String)
-}).annotations({ identifier: "ReportError" });
+}).annotate({ identifier: "ReportError" });
 
 //#endregion
 export { AgentConsoleMode, CiConsoleMode, ConsoleMode, ConsoleOutputMode, DetailLevel, Environment, Executor, HumanConsoleMode, OutputFormat, PackageManager, ReportError, TestClassification, TestRunReason, TestState };

package/schemas/ConsoleLeaks.js

@@ -12,7 +12,7 @@ const ConsoleLeakFile = Schema.Struct({
 	stderr: Schema.Number,
 	tests: Schema.optional(Schema.Array(Schema.String)),
 	sample: Schema.optional(Schema.String)
-}).annotations({ identifier: "ConsoleLeakFile" });
+}).annotate({ identifier: "ConsoleLeakFile" });
 /**
 * Aggregate stray-console-output signal for a single test run. Omitted from
 * a report entirely when the run produced no user console output.
@@ -22,7 +22,7 @@ const ConsoleLeaks = Schema.Struct({
 	total: Schema.Number,
 	byFile: Schema.Array(ConsoleLeakFile),
 	truncated: Schema.optional(Schema.Boolean)
-}).annotations({ identifier: "ConsoleLeaks" });
+}).annotate({ identifier: "ConsoleLeaks" });
 
 //#endregion
 export { ConsoleLeakFile, ConsoleLeaks };

package/schemas/Coverage.js

@@ -1,5 +1,5 @@
 import { MetricThresholds, PatternThresholds } from "./Thresholds.js";
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 
 //#region src/schemas/Coverage.ts
 /**
@@ -11,7 +11,7 @@ const CoverageTotals = Schema.Struct({
 	branches: Schema.Number,
 	functions: Schema.Number,
 	lines: Schema.Number
-}).annotations({ identifier: "CoverageTotals" });
+}).annotate({ identifier: "CoverageTotals" });
 /**
 * Per-file coverage data including uncovered line ranges.
 * @public
@@ -20,7 +20,7 @@ const FileCoverageReport = Schema.Struct({
 	file: Schema.String,
 	summary: CoverageTotals,
 	uncoveredLines: Schema.String
-}).annotations({ identifier: "FileCoverageReport" });
+}).annotate({ identifier: "FileCoverageReport" });
 /**
 * Complete coverage report attached to an AgentReport.
 * @public
@@ -29,23 +29,23 @@ const CoverageReport = Schema.Struct({
 	totals: CoverageTotals,
 	thresholds: Schema.Struct({
 		global: MetricThresholds,
-		patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+		patterns: Schema.Array(PatternThresholds).pipe(Schema.withDecodingDefaultKey(Effect.succeed([])))
 	}),
 	targets: Schema.optional(Schema.Struct({
 		global: MetricThresholds,
-		patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+		patterns: Schema.Array(PatternThresholds).pipe(Schema.withDecodingDefaultKey(Effect.succeed([])))
 	})),
 	baselines: Schema.optional(Schema.Struct({
 		global: MetricThresholds,
-		patterns: Schema.optionalWith(Schema.Array(PatternThresholds), { default: () => [] })
+		patterns: Schema.Array(PatternThresholds).pipe(Schema.withDecodingDefaultKey(Effect.succeed([])))
 	})),
-	scoped: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+	scoped: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false))),
 	scopedFiles: Schema.optional(Schema.Array(Schema.String)),
 	lowCoverage: Schema.Array(FileCoverageReport),
 	lowCoverageFiles: Schema.Array(Schema.String),
 	belowTarget: Schema.optional(Schema.Array(FileCoverageReport)),
 	belowTargetFiles: Schema.optional(Schema.Array(Schema.String))
-}).annotations({ identifier: "CoverageReport" });
+}).annotate({ identifier: "CoverageReport" });
 
 //#endregion
 export { CoverageReport, CoverageTotals, FileCoverageReport };

package/schemas/CoverageTargets.js

@@ -2,17 +2,22 @@ import { Schema } from "effect";
 
 //#region src/schemas/CoverageTargets.ts
 /**
+* A strictly-positive coverage percentage. Negatives and zeros are rejected
+* at decode time.
+*/
+const PositivePercent = Schema.Number.check(Schema.isGreaterThan(0));
+/**
 * Per-metric leaf shape for coverageTargets entries. Allows optional
 * numeric targets per metric and the `100: true` shortcut.
 * @public
 */
 const CoverageTargetsMetrics = Schema.Struct({
-	lines: Schema.optional(Schema.Positive),
-	functions: Schema.optional(Schema.Positive),
-	branches: Schema.optional(Schema.Positive),
-	statements: Schema.optional(Schema.Positive),
+	lines: Schema.optional(PositivePercent),
+	functions: Schema.optional(PositivePercent),
+	branches: Schema.optional(PositivePercent),
+	statements: Schema.optional(PositivePercent),
 	100: Schema.optional(Schema.Literal(true))
-}).annotations({ identifier: "CoverageTargetsMetrics" });
+}).annotate({ identifier: "CoverageTargetsMetrics" });
 /**
 * Typed schema for the coverageTargets option.
 *
@@ -28,12 +33,13 @@ const CoverageTargetsMetrics = Schema.Struct({
 * at key `"100"`.
 * @public
 */
-const CoverageTargets = Schema.Record({
-	key: Schema.String,
-	value: Schema.Union(Schema.Positive, Schema.Literal(true), CoverageTargetsMetrics)
-}).pipe(Schema.filter((targets) => {
+const CoverageTargets = Schema.Record(Schema.String, Schema.Union([
+	PositivePercent,
+	Schema.Literal(true),
+	CoverageTargetsMetrics
+])).check(Schema.makeFilter((targets) => {
 	for (const [key, value] of Object.entries(targets)) if (value === true && key !== "100") return `coverageTargets.${key} cannot be true. The "true" shorthand is only valid at key "100" (meaning 100% across all metrics).`;
-}), Schema.annotations({ identifier: "CoverageTargets" }));
+})).annotate({ identifier: "CoverageTargets" });
 
 //#endregion
 export { CoverageTargets, CoverageTargetsMetrics };

package/schemas/History.js

@@ -7,8 +7,8 @@ import { Schema } from "effect";
 */
 const TestRun = Schema.Struct({
 	timestamp: Schema.String,
-	state: Schema.Literal("passed", "failed")
-}).annotations({ identifier: "TestRun" });
+	state: Schema.Literals(["passed", "failed"])
+}).annotate({ identifier: "TestRun" });
 /**
 * History for a single test across multiple runs.
 * @public
@@ -17,7 +17,7 @@ const TestHistory = Schema.Struct({
 	modulePath: Schema.String,
 	fullName: Schema.String,
 	runs: Schema.Array(TestRun)
-}).annotations({ identifier: "TestHistory" });
+}).annotate({ identifier: "TestHistory" });
 /**
 * Per-project history record containing all tracked tests.
 * @public
@@ -26,7 +26,7 @@ const HistoryRecord = Schema.Struct({
 	project: Schema.String,
 	updatedAt: Schema.String,
 	tests: Schema.Array(TestHistory)
-}).annotations({ identifier: "HistoryRecord" });
+}).annotate({ identifier: "HistoryRecord" });
 
 //#endregion
 export { HistoryRecord, TestHistory, TestRun };

package/schemas/Identity.js

@@ -7,14 +7,14 @@ import { Schema } from "effect";
 * agent's lifetime.
 * @public
 */
-const AgentId = Schema.UUID.pipe(Schema.brand("AgentId"));
+const AgentId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("AgentId"));
 /**
 * The unit "all work on this feature" rolls up to. Survives
 * `claude --resume` and parallel windows; lives in the host's
 * transcript filename for Claude Code.
 * @public
 */
-const ConversationId = Schema.UUID.pipe(Schema.brand("ConversationId"));
+const ConversationId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("ConversationId"));
 /**
 * The agent host process's chat id (Claude Code's per-process chat
 * UUID, etc.). Shorter-lived than a conversation; one conversation can
@@ -22,13 +22,13 @@ const ConversationId = Schema.UUID.pipe(Schema.brand("ConversationId"));
 * `sessions.id` (the SQLite agent-run PK).
 * @public
 */
-const ChatId = Schema.UUID.pipe(Schema.brand("ChatId"));
+const ChatId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("ChatId"));
 /**
 * One TDD orchestration task. Replaces the legacy `tdd_session_id`
 * vocabulary so "session" is unambiguous in the codebase.
 * @public
 */
-const TddTaskId = Schema.UUID.pipe(Schema.brand("TddTaskId"));
+const TddTaskId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("TddTaskId"));
 /**
 * Filesystem-safe key for the per-project data store directory under
 * `$XDG_DATA_HOME/vitest-agent/<projectKey>/`. Resolved by the
@@ -37,7 +37,7 @@ const TddTaskId = Schema.UUID.pipe(Schema.brand("TddTaskId"));
 * value is `ProjectIdentityNotResolvableError`, not an empty string).
 * @public
 */
-const ProjectKey = Schema.String.pipe(Schema.minLength(1), Schema.brand("ProjectKey"));
+const ProjectKey = Schema.String.check(Schema.isMinLength(1)).pipe(Schema.brand("ProjectKey"));
 /**
 * Who initiated the action (test run, hypothesis, note, TDD phase, …).
 * Recorded on every action row alongside `agent_id`.
@@ -47,7 +47,11 @@ const ProjectKey = Schema.String.pipe(Schema.minLength(1), Schema.brand("Project
 * - `system` — a CI run, scheduler, or other non-human/non-agent actor
 * @public
 */
-const ActorType = Schema.Literal("agent", "user", "system").annotations({ identifier: "ActorType" });
+const ActorType = Schema.Literals([
+	"agent",
+	"user",
+	"system"
+]).annotate({ identifier: "ActorType" });
 /**
 * Recommended canonical host identifiers. Open enum at the SDK level so
 * a new client doesn't require an SDK release; the MCP server defaults
@@ -58,7 +62,15 @@ const ActorType = Schema.Literal("agent", "user", "system").annotations({ identi
 * match a known pattern — preferred over guessing.
 * @public
 */
-const HostKind = Schema.Literal("claude-code", "claude-desktop", "cursor", "goose", "chatgpt", "mcp-inspector", "unknown").annotations({ identifier: "HostKind" });
+const HostKind = Schema.Literals([
+	"claude-code",
+	"claude-desktop",
+	"cursor",
+	"goose",
+	"chatgpt",
+	"mcp-inspector",
+	"unknown"
+]).annotate({ identifier: "HostKind" });
 
 //#endregion
 export { ActorType, AgentId, ChatId, ConversationId, HostKind, ProjectKey, TddTaskId };

package/schemas/Options.js

@@ -23,7 +23,7 @@ const ConsoleOutputs = Schema.Struct({
 	human: Schema.optional(HumanConsoleMode),
 	agent: Schema.optional(AgentConsoleMode),
 	ci: Schema.optional(CiConsoleMode)
-}).annotations({ identifier: "ConsoleOutputs" });
+}).annotate({ identifier: "ConsoleOutputs" });
 /**
 * The 2.0 user-facing options for `AgentPlugin`.
 *
@@ -37,7 +37,7 @@ const AgentPluginOptions = Schema.Struct({
 	console: Schema.optional(ConsoleOutputs),
 	coverageTargets: Schema.optional(CoverageTargets),
 	transport: Schema.optional(Transport)
-}).annotations({ identifier: "AgentPluginOptions" });
+}).annotate({ identifier: "AgentPluginOptions" });
 /**
 * Reporter-implementation options.
 *
@@ -51,7 +51,7 @@ const AgentPluginOptions = Schema.Struct({
 */
 const AgentReporterOptions = Schema.Struct({ 
 /** Set by the plugin per-project. Filters reports to one project. */
-projectFilter: Schema.optional(Schema.String) }).annotations({ identifier: "AgentReporterOptions" });
+projectFilter: Schema.optional(Schema.String) }).annotate({ identifier: "AgentReporterOptions" });
 
 //#endregion
 export { AgentPluginOptions, AgentReporterOptions, ConsoleOutputs };

package/schemas/RenderState.js

@@ -12,10 +12,10 @@ import { Schema } from "effect";
 const TestRecord = Schema.Struct({
 	testName: Schema.String,
 	suitePath: Schema.Array(Schema.String),
-	status: Schema.Union(TestState, Schema.Literal("running", "timed-out")),
+	status: Schema.Union([TestState, Schema.Literals(["running", "timed-out"])]),
 	durationMs: Schema.NullOr(Schema.Number),
 	error: Schema.optional(ReportError)
-}).annotations({ identifier: "TestRecord" });
+}).annotate({ identifier: "TestRecord" });
 /**
 * Per-module aggregation. The reducer keeps modules keyed on
 * `modulePath` so out-of-order events can update the right slot.
@@ -23,7 +23,11 @@ const TestRecord = Schema.Struct({
 */
 const ModuleRecord = Schema.Struct({
 	modulePath: Schema.String,
-	status: Schema.Literal("queued", "running", "finished"),
+	status: Schema.Literals([
+		"queued",
+		"running",
+		"finished"
+	]),
 	passCount: Schema.Number,
 	failCount: Schema.Number,
 	skipCount: Schema.Number,
@@ -43,11 +47,8 @@ const ModuleRecord = Schema.Struct({
 	* module seeded by `ModuleQueued` (or replayed) has no start stamp.
 	*/
 	startedAt: Schema.optional(Schema.String),
-	tagCounts: Schema.optional(Schema.Record({
-		key: Schema.String,
-		value: Schema.Number
-	}))
-}).annotations({ identifier: "ModuleRecord" });
+	tagCounts: Schema.optional(Schema.Record(Schema.String, Schema.Number))
+}).annotate({ identifier: "ModuleRecord" });
 /**
 * One row in the failure list. A failure can exist before its
 * classification arrives (`FailureClassified` is emitted from a
@@ -61,7 +62,7 @@ const FailureRecord = Schema.Struct({
 	error: Schema.optional(ReportError),
 	timedOut: Schema.optional(Schema.Boolean),
 	classification: Schema.NullOr(TestClassification)
-}).annotations({ identifier: "FailureRecord" });
+}).annotate({ identifier: "FailureRecord" });
 /**
 * Coverage block, populated only after `CoverageReady`. Threshold
 * violations are accumulated separately as they arrive.
@@ -76,7 +77,7 @@ const CoverageRenderState = Schema.Struct({
 		expected: Schema.Number,
 		actual: Schema.Number
 	}))
-}).annotations({ identifier: "CoverageRenderState" });
+}).annotate({ identifier: "CoverageRenderState" });
 /**
 * A `SuggestedAction` event, denormalized into the queue the renderer reads.
 * @public
@@ -86,7 +87,7 @@ const SuggestedActionRecord = Schema.Struct({
 	title: Schema.String,
 	detail: Schema.String,
 	targetTool: Schema.optional(Schema.String)
-}).annotations({ identifier: "SuggestedActionRecord" });
+}).annotate({ identifier: "SuggestedActionRecord" });
 /**
 * Per-run totals, recomputed on every `ModuleFinished` and reconciled
 * against `RunFinished` (which carries the runner's own count).
@@ -98,7 +99,7 @@ const RenderTotals = Schema.Struct({
 	skipCount: Schema.Number,
 	timeoutCount: Schema.Number,
 	durationMs: Schema.Number
-}).annotations({ identifier: "RenderTotals" });
+}).annotate({ identifier: "RenderTotals" });
 /**
 * The renderer state. Both the human (Ink) and agent (string)
 * renderers read this shape; the reducer is the only producer.
@@ -111,25 +112,31 @@ const RenderTotals = Schema.Struct({
 * @public
 */
 const RenderState = Schema.Struct({
-	phase: Schema.Literal("idle", "running", "finished", "timed-out"),
+	phase: Schema.Literals([
+		"idle",
+		"running",
+		"finished",
+		"timed-out"
+	]),
 	runId: Schema.NullOr(Schema.String),
 	configHash: Schema.NullOr(Schema.String),
 	startedAt: Schema.NullOr(Schema.String),
 	finishedAt: Schema.NullOr(Schema.String),
-	modules: Schema.Record({
-		key: Schema.String,
-		value: ModuleRecord
-	}),
+	modules: Schema.Record(Schema.String, ModuleRecord),
 	moduleOrder: Schema.Array(Schema.String),
 	totals: RenderTotals,
 	coverage: Schema.NullOr(CoverageRenderState),
 	trend: Schema.NullOr(Schema.Struct({
-		direction: Schema.Literal("improving", "regressing", "stable"),
+		direction: Schema.Literals([
+			"improving",
+			"regressing",
+			"stable"
+		]),
 		runCount: Schema.Number
 	})),
 	failures: Schema.Array(FailureRecord),
 	suggestedActions: Schema.Array(SuggestedActionRecord)
-}).annotations({ identifier: "RenderState" });
+}).annotate({ identifier: "RenderState" });
 /**
 * Initial state — what the reducer returns when no events have been
 * applied yet. Exported so tests and the renderers' bootstrapping