@roj-ai/sdk 0.0.2

package/src/core/events/memory.ts

@@ -0,0 +1,131 @@
+import type { DomainEvent } from '~/core/events/types.js'
+import type { SessionId, SessionMetadata } from '~/core/sessions/schema.js'
+import { BaseEventStore } from './base-event-store.js'
+import type { LoadRangeOptions, LoadRangeResult } from './event-store.js'
+
+/**
+ * MemoryEventStore - In-memory event store for testing.
+ *
+ * Provides simple in-memory storage with test helpers for inspecting events.
+ */
+export class MemoryEventStore extends BaseEventStore {
+	private events = new Map<SessionId, DomainEvent[]>()
+	private metadata = new Map<SessionId, SessionMetadata>()
+
+	protected async doAppend(sessionId: SessionId, event: DomainEvent): Promise<void> {
+		const existing = this.events.get(sessionId) ?? []
+		this.events.set(sessionId, [...existing, event])
+		await this.updateMetadataFromEvents(sessionId, [event])
+	}
+
+	protected async doAppendBatch(sessionId: SessionId, events: DomainEvent[]): Promise<void> {
+		if (events.length === 0) return
+
+		const existing = this.events.get(sessionId) ?? []
+		this.events.set(sessionId, [...existing, ...events])
+		await this.updateMetadataFromEvents(sessionId, events)
+	}
+
+	async load(sessionId: SessionId): Promise<DomainEvent[]> {
+		return this.events.get(sessionId) ?? []
+	}
+
+	async exists(sessionId: SessionId): Promise<boolean> {
+		return this.events.has(sessionId)
+	}
+
+	async listSessions(): Promise<SessionId[]> {
+		return Array.from(this.events.keys())
+	}
+
+	async loadRange(
+		sessionId: SessionId,
+		options?: LoadRangeOptions,
+	): Promise<LoadRangeResult> {
+		const allEvents = this.events.get(sessionId) ?? []
+		const since = options?.since ?? -1
+		const limit = options?.limit
+
+		// toIndex always reflects the actual last event in the store (for polling cursor)
+		const storeLastIndex = allEvents.length - 1
+
+		const fromIndex = since + 1
+		if (fromIndex >= allEvents.length) {
+			// No new events, but return the actual last index so client can continue polling
+			return { events: [], fromIndex: -1, toIndex: storeLastIndex }
+		}
+
+		const endIndex = limit !== undefined
+			? Math.min(fromIndex + limit, allEvents.length)
+			: allEvents.length
+
+		const events = allEvents.slice(fromIndex, endIndex)
+
+		return {
+			events,
+			fromIndex: events.length > 0 ? fromIndex : -1,
+			toIndex: endIndex - 1,
+		}
+	}
+
+	// =========================================================================
+	// Metadata storage primitives
+	// =========================================================================
+
+	protected async readMetadata(sessionId: SessionId): Promise<SessionMetadata | null> {
+		return this.metadata.get(sessionId) ?? null
+	}
+
+	protected async writeMetadata(sessionId: SessionId, metadata: SessionMetadata): Promise<void> {
+		this.metadata.set(sessionId, metadata)
+	}
+
+	protected async getAllSessionMetadata(): Promise<SessionMetadata[]> {
+		return Array.from(this.metadata.values())
+	}
+
+	// =========================================================================
+	// Test helpers
+	// =========================================================================
+
+	/**
+	 * Clears all events and metadata.
+	 */
+	clear(): void {
+		this.events.clear()
+		this.metadata.clear()
+	}
+
+	/**
+	 * Returns all events for inspection in tests.
+	 */
+	getAll(): Map<SessionId, DomainEvent[]> {
+		return new Map(this.events)
+	}
+
+	/**
+	 * Returns event count for a session.
+	 */
+	getEventCount(sessionId: SessionId): number {
+		return this.events.get(sessionId)?.length ?? 0
+	}
+
+	/**
+	 * Returns the last event for a session.
+	 */
+	getLastEvent(sessionId: SessionId): DomainEvent | undefined {
+		const events = this.events.get(sessionId)
+		return events?.[events.length - 1]
+	}
+
+	/**
+	 * Returns events of a given type.
+	 */
+	getEventsByType(
+		sessionId: SessionId,
+		type: string,
+	): DomainEvent[] {
+		const events = this.events.get(sessionId) ?? []
+		return events.filter((e) => e.type === type)
+	}
+}

package/src/core/events/metadata-utils.ts

@@ -0,0 +1,133 @@
+/**
+ * Utility functions for computing session metadata from events.
+ * Used for metadata reconciliation after crashes.
+ */
+
+import type { agentEvents } from '~/core/agents/state.js'
+import type { DomainEvent, FactoryEventType } from '~/core/events/types.js'
+import type { llmEvents } from '~/core/llm/state.js'
+import type { SessionId, SessionMetadata, SessionMetadataMetrics } from '~/core/sessions/schema.js'
+import type { sessionEvents } from '~/core/sessions/state.js'
+import type { toolEvents } from '~/core/tools/state.js'
+import type { mailboxEvents } from '~/plugins/mailbox/state.js'
+
+export type MetadataEvent = FactoryEventType<typeof sessionEvents | typeof agentEvents | typeof llmEvents | typeof mailboxEvents | typeof toolEvents>
+
+/**
+ * Compute metrics from a list of events.
+ * This is the source of truth for what metrics should be.
+ */
+export function computeMetricsFromEvents(events: DomainEvent[]): SessionMetadataMetrics {
+	const metrics: SessionMetadataMetrics = {
+		totalEvents: events.length,
+		totalAgents: 0,
+		totalTokens: 0,
+		totalLLMCalls: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		totalCost: 0,
+		totalMessages: 0,
+		totalToolCalls: 0,
+	}
+
+	for (const event of events as MetadataEvent[]) {
+		switch (event.type) {
+			case 'agent_spawned':
+				metrics.totalAgents++
+				break
+
+			case 'inference_completed':
+				if (event.metrics) {
+					metrics.totalLLMCalls++
+					metrics.totalTokens += event.metrics.totalTokens ?? 0
+					metrics.inputTokens! += event.metrics.promptTokens ?? 0
+					metrics.outputTokens! += event.metrics.completionTokens ?? 0
+					if (event.metrics.cost !== undefined) {
+						metrics.totalCost! += event.metrics.cost
+					}
+				}
+				break
+
+			case 'mailbox_message':
+				metrics.totalMessages!++
+				break
+
+			case 'tool_started':
+				metrics.totalToolCalls!++
+				break
+		}
+	}
+
+	return metrics
+}
+
+/**
+ * Compute full metadata from events (for initial creation or full reconciliation).
+ */
+export function computeMetadataFromEvents(
+	sessionId: SessionId,
+	events: DomainEvent[],
+): SessionMetadata | null {
+	if (events.length === 0) return null
+
+	const firstEvent = events[0] as MetadataEvent
+	if (firstEvent.type !== 'session_created') {
+		return null
+	}
+
+	const lastEvent = events[events.length - 1]
+	const metrics = computeMetricsFromEvents(events)
+
+	// Determine status from events
+	let status: SessionMetadata['status'] = 'active'
+	for (const event of events as MetadataEvent[]) {
+		if (event.type === 'session_closed') {
+			status = 'closed'
+		} else if (event.type === 'session_reopened') {
+			status = 'active'
+		}
+		// Check for errored state - if last event is inference_failed, session might be errored
+		if (event.type === 'inference_failed') {
+			// Only mark as errored if it's the most recent significant event
+			// This is a heuristic - actual status should come from session state
+		}
+	}
+
+	return {
+		sessionId,
+		presetId: firstEvent.presetId,
+		createdAt: firstEvent.timestamp,
+		lastActivityAt: lastEvent.timestamp,
+		status,
+		metrics,
+	}
+}
+
+/**
+ * Check if stored metadata needs reconciliation by comparing key metrics.
+ * Returns true if reconciliation is needed.
+ */
+export function needsReconciliation(
+	stored: SessionMetadata | null,
+	computed: SessionMetadata,
+): boolean {
+	if (!stored) return true
+	if (!stored.metrics) return true
+	if (!computed.metrics) return false
+
+	// Check totalEvents as the primary consistency indicator
+	if (stored.metrics.totalEvents !== computed.metrics.totalEvents) {
+		return true
+	}
+
+	// Check other metrics for consistency
+	if (stored.metrics.totalAgents !== computed.metrics.totalAgents) {
+		return true
+	}
+
+	if (stored.metrics.totalLLMCalls !== computed.metrics.totalLLMCalls) {
+		return true
+	}
+
+	return false
+}

package/src/core/events/test-helpers.ts

@@ -0,0 +1,31 @@
+/**
+ * Helpers for creating branded DomainEvent objects.
+ *
+ * Event factories (sessionEvents, agentEvents, etc.) produce events
+ * without `sessionId` (it's added by `emitEvent()` at runtime).
+ * `withSessionId` adds the missing field and returns a full DomainEvent.
+ *
+ * Usage:
+ *   const event = withSessionId(sessionId, sessionEvents.create('session_created', { presetId: 'test' }))
+ */
+import type { BaseEvent } from '~/core/events/types.js'
+import type { DomainEvent } from '~/core/events/types.js'
+import type { SessionId } from '~/core/sessions/schema.js'
+
+/**
+ * Add `sessionId` to a factory-created event, producing a full DomainEvent.
+ *
+ * The factory `.create()` returns `Omit<BaseEvent<K>, 'sessionId'> & payload`
+ * (branded but missing sessionId). This function adds the missing field.
+ *
+ * TypeScript cannot prove `Omit<Union, 'key'> & { key }` reconstructs the
+ * original union (Omit destroys discriminants). The return type uses the same
+ * brand-bridging pattern as `createEventsFactory` — safe because all factory
+ * events with sessionId are structurally valid DomainEvent members.
+ */
+export function withSessionId<T extends Omit<BaseEvent<string>, 'sessionId'>>(
+	sessionId: SessionId,
+	event: T,
+): T & { sessionId: SessionId } & DomainEvent {
+	return Object.assign(event, { sessionId }) as T & { sessionId: SessionId } & DomainEvent
+}

package/src/core/events/types.ts

@@ -0,0 +1,64 @@
+import z4 from 'zod/v4'
+import { SessionId } from '~/core/sessions/schema'
+
+declare const __brand: unique symbol
+type TheBrand<B> = { [__brand]: B }
+type Brand<T, B> = T & TheBrand<B>
+
+export type BaseEvent<T extends string> = Brand<{
+	sessionId: SessionId
+	timestamp: number
+	type: T
+}, 'Event'>
+
+export type EventsMap = Record<string, z4.ZodObject<z4.ZodRawShape>>
+
+export type EventUnion<TEvents extends EventsMap> = {
+	[K in keyof TEvents & string]: BaseEvent<K> & z4.infer<TEvents[K]>
+}[keyof TEvents & string]
+
+type EventsOf<TEvents extends EventsMap> = {
+	[K in keyof TEvents & string]: BaseEvent<K> & z4.infer<TEvents[K]>
+}
+
+export interface EventsFactory<TEvents extends EventsMap> {
+	create<K extends keyof TEvents & string>(type: K, input: z4.infer<TEvents[K]>): Omit<BaseEvent<K>, 'sessionId'> & z4.infer<TEvents[K]>
+	EventType: EventUnion<TEvents>
+	Events: EventsOf<TEvents>
+}
+
+/**
+ * Extract the event union type from an EventsFactory instance.
+ * Usage: FactoryEventType<typeof sessionEvents | typeof agentEvents>
+ */
+export type FactoryEventType<F extends { EventType: unknown }> = F['EventType'] & BaseEvent<string>
+
+/**
+ * Generic domain event type — any event with sessionId, timestamp, and type.
+ * Replaces the monolithic DomainEvent union from events.ts.
+ * Individual reducers use their own narrower event types via EventsFactory.
+ */
+export type DomainEvent = BaseEvent<string>
+
+/**
+ * Type guard to check if an unknown value is a DomainEvent.
+ */
+export const isDomainEvent = (event: unknown): event is DomainEvent =>
+	typeof event === 'object'
+	&& event !== null
+	&& 'type' in event
+	&& 'sessionId' in event
+	&& 'timestamp' in event
+
+export const createEventsFactory = <TEvents extends EventsMap>(_args: { events: TEvents }): EventsFactory<TEvents> => {
+	return {
+		create: (type, input) => ({
+			type,
+			...input,
+			...({} as TheBrand<'Event'>),
+			timestamp: Date.now(),
+		}),
+		EventType: undefined!,
+		Events: undefined!,
+	}
+}

package/src/core/file-store/file-store.ts

@@ -0,0 +1,275 @@
+/**
+ * SessionFileStore - single FileStore implementation with path resolution.
+ *
+ * Encapsulates all path resolution logic (sandboxed virtual paths, traversal
+ * validation, agent-visible path mapping). Replaces the separate path-resolver
+ * functions for FileStore consumers.
+ *
+ * Three scopes:
+ * - 'full': accepts agent-visible paths (/home/user/session/... or real paths)
+ * - 'session': paths relative to sessionDir
+ * - 'workspace': paths relative to workspaceDir
+ */
+
+import { dirname, join, normalize, resolve } from 'node:path'
+import type { FileEntry, FileStore } from '~/core/file-store/types.js'
+import type { FileSystem } from '~/platform/fs.js'
+import { Err, Ok } from '~/lib/utils/result.js'
+import type { Result } from '~/lib/utils/result.js'
+
+// Virtual roots for sandboxed mode
+const VIRTUAL_SESSION = '/home/user/session'
+const VIRTUAL_WORKSPACE = '/home/user/workspace'
+
+type FileStoreScope = 'full' | 'session' | 'workspace'
+
+export class SessionFileStore implements FileStore {
+	constructor(
+		private readonly sessionDir: string,
+		private readonly workspaceDir: string | undefined,
+		private readonly sandboxed: boolean,
+		private readonly fs: FileSystem,
+		private readonly scope: FileStoreScope = 'full',
+	) {}
+
+	/** Create a session-scoped FileStore (relative paths → sessionDir) */
+	get session(): SessionFileStore {
+		return new SessionFileStore(this.sessionDir, this.workspaceDir, this.sandboxed, this.fs, 'session')
+	}
+
+	/** Create a workspace-scoped FileStore (relative paths → workspaceDir), or undefined if no workspace */
+	get workspace(): SessionFileStore | undefined {
+		if (!this.workspaceDir) return undefined
+		return new SessionFileStore(this.sessionDir, this.workspaceDir, this.sandboxed, this.fs, 'workspace')
+	}
+
+	async write(path: string, content: string | Buffer): Promise<Result<{ path: string }, string>> {
+		const resolved = this.resolvePath(path)
+		if (!resolved.ok) return resolved
+
+		await this.fs.mkdir(dirname(resolved.value), { recursive: true })
+		await this.fs.writeFile(resolved.value, content)
+
+		return Ok({ path: this.toAgentPath(resolved.value) })
+	}
+
+	async read(path: string): Promise<Result<string, string>>
+	async read(path: string, opts: { type: 'buffer' }): Promise<Result<Buffer, string>>
+	async read(path: string, opts?: { type: 'buffer' }): Promise<Result<string | Buffer, string>> {
+		const resolved = this.resolvePath(path)
+		if (!resolved.ok) return resolved
+
+		try {
+			if (opts?.type === 'buffer') {
+				return Ok(await this.fs.readFile(resolved.value))
+			}
+			return Ok(await this.fs.readFile(resolved.value, 'utf-8'))
+		} catch {
+			return Err(`File not found: ${path}`)
+		}
+	}
+
+	async exists(path: string): Promise<Result<boolean, string>> {
+		const resolved = this.resolvePath(path)
+		if (!resolved.ok) return resolved
+
+		return Ok(await this.fs.exists(resolved.value))
+	}
+
+	async stat(path: string): Promise<Result<FileEntry, string>> {
+		const resolved = this.resolvePath(path)
+		if (!resolved.ok) return resolved
+
+		try {
+			const s = await this.fs.stat(resolved.value)
+			return Ok({
+				size: s.size,
+				type: s.isFile() ? 'file' : s.isDirectory() ? 'directory' : s.isSymbolicLink() ? 'symlink' : 'other',
+				name: resolved.value.split('/').pop() || '',
+			})
+		} catch {
+			return Err(`Not found: ${path}`)
+		}
+	}
+
+	async list(path: string): Promise<Result<FileEntry[], string>> {
+		const resolved = this.resolvePath(path)
+		if (!resolved.ok) return resolved
+
+		try {
+			const items = await this.fs.readdir(resolved.value, { withFileTypes: true })
+			const entries: FileEntry[] = []
+			for (const item of items) {
+				let type: FileEntry['type']
+				let size: number | undefined
+				if (item.isFile()) {
+					type = 'file'
+					const s = await this.fs.stat(join(resolved.value, item.name))
+					size = s.size
+				} else if (item.isDirectory()) {
+					type = 'directory'
+				} else if (item.isSymbolicLink()) {
+					type = 'symlink'
+				} else {
+					type = 'other'
+				}
+				entries.push({ name: item.name, type, size })
+			}
+			return Ok(entries)
+		} catch {
+			return Err(`Directory not found: ${path}`)
+		}
+	}
+
+	async remove(path: string): Promise<Result<void, string>> {
+		const resolved = this.resolvePath(path)
+		if (!resolved.ok) return resolved
+
+		try {
+			await this.fs.unlink(resolved.value)
+			return Ok(undefined)
+		} catch {
+			return Err(`Failed to remove: ${path}`)
+		}
+	}
+
+	getRoots(): { session: string; workspace?: string } {
+		if (this.sandboxed) {
+			return {
+				session: VIRTUAL_SESSION,
+				workspace: this.workspaceDir ? VIRTUAL_WORKSPACE : undefined,
+			}
+		}
+		return {
+			session: this.sessionDir,
+			workspace: this.workspaceDir,
+		}
+	}
+
+	realPath(path: string): Result<string, string> {
+		return this.resolvePath(path)
+	}
+
+	scoped(basePath: string): SessionFileStore {
+		// Resolve basePath relative to current scope
+		const resolved = this.resolvePath(basePath)
+		if (!resolved.ok) {
+			throw new Error(`Cannot scope to invalid path: ${basePath}`)
+		}
+		return new SessionFileStore(resolved.value, undefined, false, this.fs, 'session')
+	}
+
+	// ============================================================================
+	// Path resolution
+	// ============================================================================
+
+	private resolvePath(path: string): Result<string, string> {
+		switch (this.scope) {
+			case 'full':
+				return this.resolveAgentPath(path)
+			case 'session':
+				return this.resolveRelativePath(path, this.sessionDir)
+			case 'workspace':
+				if (!this.workspaceDir) return Err('No workspace directory configured')
+				return this.resolveRelativePath(path, this.workspaceDir)
+		}
+	}
+
+	/** Resolve a relative path within a root directory */
+	private resolveRelativePath(path: string, rootDir: string): Result<string, string> {
+		const normalized = normalize(path)
+		if (normalized.startsWith('..') || normalized.startsWith('/')) {
+			return Err(`Path traversal not allowed: ${path}`)
+		}
+		const absolute = resolve(join(rootDir, normalized))
+		if (!absolute.startsWith(rootDir)) {
+			return Err(`Path traversal not allowed: ${path}`)
+		}
+		return Ok(absolute)
+	}
+
+	/** Resolve an agent-visible path to real filesystem path (handles sandboxed virtual paths) */
+	private resolveAgentPath(agentPath: string): Result<string, string> {
+		if (this.sandboxed) {
+			return this.resolveSandboxedPath(agentPath)
+		}
+		return this.resolveNonSandboxedPath(agentPath)
+	}
+
+	private resolveSandboxedPath(agentPath: string): Result<string, string> {
+		if (agentPath.startsWith(VIRTUAL_SESSION + '/') || agentPath === VIRTUAL_SESSION) {
+			const relative = agentPath.slice(VIRTUAL_SESSION.length)
+			const absolutePath = resolve(this.sessionDir, relative.slice(1) || '.')
+			return this.validateWithinRoot(absolutePath, this.sessionDir, agentPath)
+		}
+
+		if (agentPath.startsWith(VIRTUAL_WORKSPACE + '/') || agentPath === VIRTUAL_WORKSPACE) {
+			if (!this.workspaceDir) {
+				return Err('No workspace directory is configured for this session. Only session paths are available.')
+			}
+			const relative = agentPath.slice(VIRTUAL_WORKSPACE.length)
+			const absolutePath = resolve(this.workspaceDir, relative.slice(1) || '.')
+			return this.validateWithinRoot(absolutePath, this.workspaceDir, agentPath)
+		}
+
+		const validPrefixes = this.workspaceDir
+			? `${VIRTUAL_SESSION}/ or ${VIRTUAL_WORKSPACE}/`
+			: `${VIRTUAL_SESSION}/`
+
+		return Err(`Path must start with ${validPrefixes}. Got: '${agentPath}'`)
+	}
+
+	private resolveNonSandboxedPath(agentPath: string): Result<string, string> {
+		const absolutePath = resolve(agentPath)
+		const normalizedSession = resolve(this.sessionDir)
+		const normalizedWorkspace = this.workspaceDir ? resolve(this.workspaceDir) : null
+
+		const isInSession = absolutePath === normalizedSession || absolutePath.startsWith(normalizedSession + '/')
+		const isInWorkspace = normalizedWorkspace
+			&& (absolutePath === normalizedWorkspace || absolutePath.startsWith(normalizedWorkspace + '/'))
+
+		if (!isInSession && !isInWorkspace) {
+			return Err(`Path '${agentPath}' is outside allowed directories`)
+		}
+
+		return Ok(absolutePath)
+	}
+
+	private validateWithinRoot(absolutePath: string, rootDir: string, originalPath: string): Result<string, string> {
+		const normalizedRoot = resolve(rootDir)
+		const isWithin = absolutePath === normalizedRoot || absolutePath.startsWith(normalizedRoot + '/')
+
+		if (!isWithin) {
+			return Err(`Path '${originalPath}' resolves outside allowed directories`)
+		}
+
+		return Ok(absolutePath)
+	}
+
+	// ============================================================================
+	// Agent-visible path conversion
+	// ============================================================================
+
+	private toAgentPath(realPath: string): string {
+		if (!this.sandboxed) return realPath
+
+		const normalizedSession = resolve(this.sessionDir)
+		const normalizedWorkspace = this.workspaceDir ? resolve(this.workspaceDir) : null
+
+		// Try workspace first (more specific match if workspace is inside session)
+		if (normalizedWorkspace) {
+			if (realPath === normalizedWorkspace) return VIRTUAL_WORKSPACE
+			if (realPath.startsWith(normalizedWorkspace + '/')) {
+				return VIRTUAL_WORKSPACE + realPath.slice(normalizedWorkspace.length)
+			}
+		}
+
+		if (realPath === normalizedSession) return VIRTUAL_SESSION
+		if (realPath.startsWith(normalizedSession + '/')) {
+			return VIRTUAL_SESSION + realPath.slice(normalizedSession.length)
+		}
+
+		// Path is outside known roots - return as-is
+		return realPath
+	}
+}

package/src/core/file-store/types.ts

@@ -0,0 +1,52 @@
+/**
+ * FileStore interface for centralized file operations.
+ * All paths are relative to the store's root directory.
+ * Used by tools, lib functions, and the LLM provider.
+ */
+
+import type { Result } from '~/lib/utils/result.js'
+
+export interface FileStat {
+	size: number
+	isFile: boolean
+	isDirectory: boolean
+}
+
+export interface FileEntry {
+	name: string
+	type: 'file' | 'directory' | 'symlink' | 'other'
+	size?: number
+}
+
+export interface FileStore {
+	/** Write text or binary content. Auto-creates parent dirs. Returns the agent-visible path. */
+	write(path: string, content: string | Buffer): Promise<Result<{ path: string }, string>>
+
+	/** Read file as UTF-8 text. */
+	read(path: string): Promise<Result<string, string>>
+	/** Read file as Buffer. */
+	read(path: string, opts: { type: 'buffer' }): Promise<Result<Buffer, string>>
+
+	/** Check if a file exists. */
+	exists(path: string): Promise<Result<boolean, string>>
+
+	/** Get file/directory stats. */
+	stat(path: string): Promise<Result<FileEntry, string>>
+
+	/** List entries in a directory with type and size info. */
+	list(path: string, options?: { maxDepth?: number; gitIgnore?: boolean }): Promise<Result<FileEntry[], string>>
+
+	/** Remove a file. */
+	remove(path: string): Promise<Result<void, string>>
+
+	/** Resolve an agent-visible path to real filesystem path. */
+	realPath(path: string): Result<string, string>
+
+	/** Get the agent-visible root paths (virtual when sandboxed, real otherwise) */
+	getRoots(): { session: string; workspace?: string }
+
+	scoped(subPath: string): FileStore
+
+	session: FileStore
+	workspace?: FileStore
+}