@abloatai/ablo 0.3.0

package/dist/SyncEngineContext.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SyncEngineContext — Runtime dependency container
+ *
+ * All SDK classes receive this context at construction time.
+ * It bundles every injectable dependency so constructors stay clean.
+ */
+import type { SyncLogger, SyncObservabilityProvider, SyncAnalytics, SessionErrorDetector, OnlineStatusProvider, ModelDebugLoggerContract, MutationExecutor, MutationDispatcher, SyncEngineConfig } from './interfaces/index.js';
+export interface SyncEngineContext {
+    /** Structured logger */
+    logger: SyncLogger;
+    /** Error tracking & performance monitoring */
+    observability: SyncObservabilityProvider;
+    /** Product analytics (optional) */
+    analytics?: SyncAnalytics;
+    /** Session error detection for auth redirect decisions */
+    sessionErrorDetector: SessionErrorDetector;
+    /** Network connectivity detection */
+    onlineStatus: OnlineStatusProvider;
+    /** Model operation debug logging (optional, dev-only) */
+    modelDebugLogger?: ModelDebugLoggerContract;
+    /** Backend mutation transport (GraphQL, REST, etc.) */
+    mutationExecutor: MutationExecutor;
+    /** Offline mutation replay dispatcher */
+    mutationDispatcher: MutationDispatcher;
+    /** Application-specific sync configuration */
+    config: SyncEngineConfig;
+}
+/** No-op logger — silently discards all log calls */
+export declare const noopLogger: SyncLogger;
+/** No-op observability — silently discards all observability calls */
+export declare const noopObservability: SyncObservabilityProvider;
+/** No-op analytics — silently discards all analytics calls */
+export declare const noopAnalytics: SyncAnalytics;
+/** Browser-native online status provider */
+export declare const browserOnlineStatus: OnlineStatusProvider;
+/** Permissive session error detector — treats 401/403 as session errors */
+export declare const defaultSessionErrorDetector: SessionErrorDetector;
+/**
+ * Fallback config used when the context is read before
+ * `createSyncEngine(...)` has initialized it (tests, early-boot code
+ * paths). An empty `modelCreatePriority` means every model falls through
+ * to `defaultCreatePriority`, so ordering is flat — fine for tests that
+ * never exercise FK ordering; consumers who do rely on it should finish
+ * wiring the engine before the first `create()` fires.
+ */
+export declare const emptyConfig: SyncEngineConfig;

package/dist/SyncEngineContext.js

@@ -0,0 +1,74 @@
+/**
+ * SyncEngineContext — Runtime dependency container
+ *
+ * All SDK classes receive this context at construction time.
+ * It bundles every injectable dependency so constructors stay clean.
+ */
+// ─────────────────────────────────────────────
+// No-op defaults for optional dependencies
+// ─────────────────────────────────────────────
+/** No-op logger — silently discards all log calls */
+export const noopLogger = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+};
+/** No-op observability — silently discards all observability calls */
+export const noopObservability = {
+    setContext() { },
+    setConnectionState() { },
+    breadcrumb() { },
+    captureRollback() { },
+    captureTransactionFailure() { },
+    captureBootstrapFailure() { },
+    captureReconciliation() { },
+    captureDeltaRetryExhausted() { },
+    captureWebSocketError() { },
+    captureOfflineFlushFailure() { },
+    captureSelfHealing() { },
+    captureCommitZeroSyncId() { },
+    startSpan(_name, _op, fn, _attributes) {
+        return fn();
+    },
+    async startSpanAsync(_name, _op, fn, _attributes) {
+        return fn();
+    },
+};
+/** No-op analytics — silently discards all analytics calls */
+export const noopAnalytics = {
+    capture() { },
+};
+/** Browser-native online status provider */
+export const browserOnlineStatus = {
+    isOnline() {
+        return typeof navigator !== 'undefined' ? navigator.onLine : true;
+    },
+};
+/** Permissive session error detector — treats 401/403 as session errors */
+export const defaultSessionErrorDetector = {
+    isSessionError(error) {
+        if (error && typeof error === 'object' && 'isSessionError' in error) {
+            return error.isSessionError === true;
+        }
+        return false;
+    },
+    isSessionErrorResponse(status) {
+        return status === 401 || status === 403;
+    },
+};
+/**
+ * Fallback config used when the context is read before
+ * `createSyncEngine(...)` has initialized it (tests, early-boot code
+ * paths). An empty `modelCreatePriority` means every model falls through
+ * to `defaultCreatePriority`, so ordering is flat — fine for tests that
+ * never exercise FK ordering; consumers who do rely on it should finish
+ * wiring the engine before the first `create()` fires.
+ */
+export const emptyConfig = {
+    modelCreatePriority: new Map(),
+    defaultCreatePriority: 40,
+    defaultNonCreatePriority: 50,
+    essentialFields: {},
+    classNameFallbackMap: {},
+};

package/dist/adapters/alwaysOnline.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Always-online network provider — for Node.js / agent / sidecar.
+ *
+ * The server IS the network — it doesn't go offline. If the Postgres
+ * connection drops, that's a database error, not a network error.
+ * The "online/offline" concept only applies to browser clients that
+ * can lose their WiFi connection.
+ *
+ * Implements OnlineStatusProvider (same interface as browserOnlineStatus).
+ */
+import type { OnlineStatusProvider } from '../interfaces/index.js';
+/**
+ * Returns an OnlineStatusProvider that always reports online.
+ * `onStatusChange` never fires — the network never transitions.
+ */
+export declare function alwaysOnline(): OnlineStatusProvider;

package/dist/adapters/alwaysOnline.js

@@ -0,0 +1,19 @@
+/**
+ * Always-online network provider — for Node.js / agent / sidecar.
+ *
+ * The server IS the network — it doesn't go offline. If the Postgres
+ * connection drops, that's a database error, not a network error.
+ * The "online/offline" concept only applies to browser clients that
+ * can lose their WiFi connection.
+ *
+ * Implements OnlineStatusProvider (same interface as browserOnlineStatus).
+ */
+/**
+ * Returns an OnlineStatusProvider that always reports online.
+ * `onStatusChange` never fires — the network never transitions.
+ */
+export function alwaysOnline() {
+    return {
+        isOnline: () => true,
+    };
+}

package/dist/adapters/inMemoryStorage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In-memory storage adapter — replaces IndexedDB for Node.js / agent / test.
+ *
+ * Implements {@link ObjectStoreContract}, the shared surface that
+ * IDB-backed `ObjectStore` also satisfies. Centralized contract so a
+ * future drift between the two trips a typecheck error here, not
+ * silently in a caller.
+ *
+ * No persistence — cleared on process restart. This is intentional:
+ * the Node sync-server and agent workers get their state from the
+ * server's delta stream, not from a local cache.
+ */
+import type { ObjectStoreContract } from '../stores/ObjectStoreContract.js';
+export declare class InMemoryObjectStore implements ObjectStoreContract {
+    readonly modelName: string;
+    readonly storeName: string;
+    private data;
+    private indexes;
+    constructor(modelName: string, storeName: string, indexNames?: string[]);
+    put(record: Record<string, unknown>): Promise<void>;
+    get(id: string): Promise<Record<string, unknown> | undefined>;
+    getAll(): Promise<Record<string, unknown>[]>;
+    delete(id: string): Promise<void>;
+    getAllFromIndex(indexName: string, value: IDBValidKey): Promise<Record<string, unknown>[]>;
+    clear(): Promise<void>;
+    /** No-op — in-memory stores don't need closing. */
+    markAsClosing(): void;
+    private addToIndexes;
+    private removeFromIndexes;
+}

package/dist/adapters/inMemoryStorage.js

@@ -0,0 +1,94 @@
+/**
+ * In-memory storage adapter — replaces IndexedDB for Node.js / agent / test.
+ *
+ * Implements {@link ObjectStoreContract}, the shared surface that
+ * IDB-backed `ObjectStore` also satisfies. Centralized contract so a
+ * future drift between the two trips a typecheck error here, not
+ * silently in a caller.
+ *
+ * No persistence — cleared on process restart. This is intentional:
+ * the Node sync-server and agent workers get their state from the
+ * server's delta stream, not from a local cache.
+ */
+export class InMemoryObjectStore {
+    modelName;
+    storeName;
+    data = new Map();
+    indexes = new Map();
+    constructor(modelName, storeName, indexNames = []) {
+        this.modelName = modelName;
+        this.storeName = storeName;
+        for (const name of indexNames) {
+            this.indexes.set(name, new Map());
+        }
+    }
+    async put(record) {
+        const id = record.id;
+        if (!id)
+            return;
+        // Remove from old index entries if updating
+        const existing = this.data.get(id);
+        if (existing) {
+            this.removeFromIndexes(id, existing);
+        }
+        this.data.set(id, { ...record });
+        this.addToIndexes(id, record);
+    }
+    async get(id) {
+        return this.data.get(id);
+    }
+    async getAll() {
+        return [...this.data.values()];
+    }
+    async delete(id) {
+        const existing = this.data.get(id);
+        if (existing) {
+            this.removeFromIndexes(id, existing);
+            this.data.delete(id);
+        }
+    }
+    async getAllFromIndex(indexName, value) {
+        const index = this.indexes.get(indexName);
+        if (!index)
+            return [];
+        // The in-memory index stores values as strings (it doesn't support
+        // the full IDB key range — Date / BufferSource / arrays). For the
+        // overwhelmingly-common case of string FK ids, coercing through
+        // String() preserves the existing behavior while satisfying the
+        // shared `ObjectStoreContract` signature.
+        const ids = index.get(String(value));
+        if (!ids)
+            return [];
+        return [...ids]
+            .map((id) => this.data.get(id))
+            .filter((r) => r != null);
+    }
+    async clear() {
+        this.data.clear();
+        for (const index of this.indexes.values()) {
+            index.clear();
+        }
+    }
+    /** No-op — in-memory stores don't need closing. */
+    markAsClosing() { }
+    addToIndexes(id, record) {
+        for (const [indexName, indexMap] of this.indexes) {
+            const value = record[indexName];
+            if (value != null) {
+                const key = String(value);
+                if (!indexMap.has(key))
+                    indexMap.set(key, new Set());
+                indexMap.get(key).add(id);
+            }
+        }
+    }
+    removeFromIndexes(id, record) {
+        for (const [indexName, indexMap] of this.indexes) {
+            const value = record[indexName];
+            if (value != null) {
+                const key = String(value);
+                indexMap.get(key)?.delete(id);
+            }
+        }
+    }
+}

package/dist/agent/Agent.d.ts

@@ -0,0 +1,358 @@
+/**
+ * Agent — AI SDK v6 native hooks for agent awareness.
+ *
+ * Slots directly into generateText / streamText / ToolLoopAgent via three
+ * hooks: prepareStep (inject awareness before each step), onStepFinish
+ * (announce activity after each step), and wrapTool (wrap mutation tools
+ * with freshness checks). Stateless REST under the hood — works with any
+ * API model, no WebSocket.
+ *
+ * ```ts
+ * import { generateText, tool, stepCountIs } from 'ai';
+ * import { Agent } from '@ablo/sync-engine-internal/agent';
+ *
+ * const perception = new Agent({
+ *   syncServerUrl: 'http://localhost:8080',
+ *   agentId: 'researcher-1',
+ *   organizationId: 'org-1',
+ *   syncGroups: ['deal:abc'],
+ * });
+ *
+ * const result = await generateText({
+ *   model: 'anthropic/claude-sonnet-4.5',
+ *   messages,
+ *   stopWhen: stepCountIs(10),
+ *   tools: {
+ *     updateSlide: perception.wrapTool(
+ *       tool({
+ *         inputSchema: z.object({ id: z.string(), title: z.string() }),
+ *         execute: async ({ id, title }) => { ... },
+ *       }),
+ *       { entityType: 'Slide', getEntityId: (args) => args.id },
+ *     ),
+ *   },
+ *   prepareStep: perception.prepareStep(),     // injects awareness
+ *   onStepFinish: perception.onStepFinish(),   // announces activity
+ * });
+ * ```
+ *
+ * Low-level primitives (gather, checkFreshness, announce) are also exposed
+ * for custom integrations outside the AI SDK.
+ */
+import type { PresenceAnnouncer, AgentContext } from './types.js';
+import type { Activity, IntentClaim } from '../types/streams.js';
+import { createAgentSession } from './session.js';
+export type { AgentContext } from './types.js';
+export type { IntentClaim } from '../types/streams.js';
+/**
+ * Shape returned by the sync server's REST `/api/presence` endpoint.
+ *
+ * Local to this module, NOT exported. The server still speaks the
+ * legacy vocabulary (`userId`, `isAgent`, `updatedAt`); the engine has
+ * moved on to `participantId` / `participantKind` / `lastActive`.
+ * `gather()` returns this shape verbatim today; once the server
+ * adopts the engine names this interface deletes and the response is
+ * typed as the canonical `Peer`.
+ */
+interface WirePeer {
+    userId: string;
+    isAgent?: boolean;
+    status: 'online' | 'away' | 'offline' | (string & {});
+    syncGroups?: string[];
+    activity?: Activity;
+    updatedAt?: number;
+    organizationId?: string;
+    activeIntents?: IntentClaim[];
+}
+import type { SyncLogger } from '../interfaces/index.js';
+export interface AgentOptions {
+    /** Base URL of the sync server, e.g. `http://localhost:8080`. */
+    syncServerUrl: string;
+    /** Unique agent identifier — without the `agent:` prefix. */
+    agentId: string;
+    /** Organization this agent belongs to. */
+    organizationId: string;
+    /** Sync groups determine which other participants are visible. */
+    syncGroups: string[];
+    /** Optional bearer token for authenticated requests. */
+    authToken?: string;
+    /** Custom fetch — defaults to global fetch. Useful for testing. */
+    fetch?: typeof fetch;
+    /** Timeout per request in ms. Default 5000. */
+    timeoutMs?: number;
+    /**
+     * Optional presence announcer — route `announce()` through this instead
+     * of REST. Pass a connected SyncAgent here to reuse its WebSocket and
+     * avoid per-step HTTP round trips.
+     */
+    announcer?: PresenceAnnouncer;
+    /**
+     * Optional logger. The agent SDK runs in standalone Node processes
+     * that don't share the SyncEngineContext, so Agent takes
+     * its own logger handle. Defaults to a console-backed logger; pass
+     * your structured logger (Pino, Winston, etc.) to get consistent
+     * agent-worker log routing.
+     */
+    logger?: SyncLogger;
+}
+export interface GatherOptions {
+    /** Focus context on these entities — format: "ModelName:id". */
+    focusEntities?: string[];
+    /** Maximum output characters for the formatted prompt. Default 2000. */
+    maxChars?: number;
+    /** Include presence of other participants. Default true. */
+    includePresence?: boolean;
+    /** Exclude this agent's own presence from the output. Default true. */
+    excludeSelf?: boolean;
+}
+export interface AgentSnapshot {
+    timestamp: number;
+    presence: WirePeer[];
+}
+export interface GatherResult {
+    /** Natural-language summary ready to inject as a system message. */
+    prompt: string;
+    /** Structured data for programmatic use. */
+    snapshot: AgentSnapshot;
+}
+export interface FreshnessCheck {
+    stale: boolean;
+    reason?: 'ok' | 'not_found' | 'modified';
+    /** Current entity state from the server. */
+    currentState?: Record<string, unknown>;
+    lastModifiedBy?: string;
+    lastModifiedAt?: number;
+    /** Human-readable summary — feed this back to the LLM when stale. */
+    summary?: string;
+    /**
+     * Pending-mutation intents from OTHER participants targeting this
+     * entity (self-intents filtered out). Empty = no one else is
+     * currently generating against this entity. Non-empty is ADVISORY
+     * — the agent can proceed, wait, or defer. Stale-read protection
+     * that predates committed deltas.
+     */
+    pendingIntents?: IntentClaim[];
+}
+/** Subset of AI SDK's ModelMessage — structural. */
+export interface AgentMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: unknown;
+}
+/** Subset of AI SDK's prepareStep context. */
+export interface PrepareStepContext<M extends AgentMessage = AgentMessage> {
+    stepNumber: number;
+    steps: ReadonlyArray<{
+        toolCalls?: ReadonlyArray<{
+            toolName: string;
+            input?: unknown;
+            args?: unknown;
+        }>;
+        toolResults?: ReadonlyArray<unknown>;
+    }>;
+    messages: M[];
+    model?: unknown;
+}
+/** Subset of AI SDK's prepareStep return shape. */
+export interface PrepareStepResult<M extends AgentMessage = AgentMessage> {
+    messages?: M[];
+    model?: unknown;
+    toolChoice?: unknown;
+    activeTools?: string[];
+}
+/** Subset of AI SDK's onStepFinish context. */
+export interface StepFinishContext {
+    stepType?: 'initial' | 'continue' | 'tool-result';
+    finishReason?: string;
+    text?: string;
+    toolCalls?: ReadonlyArray<{
+        toolName: string;
+        input?: unknown;
+        args?: unknown;
+    }>;
+    toolResults?: ReadonlyArray<unknown>;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+}
+/** Subset of AI SDK's ToolExecutionOptions. */
+export interface ToolExecutionOptions {
+    toolCallId?: string;
+    messages?: AgentMessage[];
+    abortSignal?: AbortSignal;
+    experimental_context?: unknown;
+}
+/** Minimal tool shape — a subset of AI SDK's Tool type. */
+export interface AgentTool<TArgs = unknown, TResult = unknown> {
+    description?: string;
+    inputSchema?: unknown;
+    execute?: (args: TArgs, options: ToolExecutionOptions) => Promise<TResult> | TResult;
+    [extra: string]: unknown;
+}
+export interface PrepareStepOptions {
+    /** Max characters of awareness context to inject. Default 1500. */
+    maxChars?: number;
+    /**
+     * Derive focus entities from recent tool calls so the LLM sees participants
+     * working on the same entities. Requires a mapper from tool call to entity
+     * tokens (format: "ModelName:id"). Default: no auto-focus.
+     */
+    focusFromToolCalls?: (toolCall: {
+        toolName: string;
+        input?: unknown;
+        args?: unknown;
+    }) => string[] | undefined;
+    /** Skip awareness injection for step 0 (initial prompt). Default false. */
+    skipFirstStep?: boolean;
+}
+export interface OnStepFinishOptions {
+    /**
+     * Derive an activity announcement from the finished step. Return null to
+     * skip announcing for this step. Default: announces the last tool name
+     * if any tool was called.
+     */
+    activity?: (ctx: StepFinishContext) => Activity | null;
+}
+export interface WrapToolOptions<TArgs> {
+    /** Entity type the tool mutates — e.g. "Slide", "Sheet". */
+    entityType: string;
+    /** Extract the entity id from the tool's args. */
+    getEntityId: (args: TArgs) => string | undefined;
+    /**
+     * Resolve the timestamp the LLM last saw this entity. If omitted or it
+     * returns 0, the freshness check is skipped (no baseline to compare).
+     */
+    lastSeenAt?: (args: TArgs, options: ToolExecutionOptions) => number | undefined;
+    /**
+     * Announce that the agent is about to work on this entity before executing.
+     * Default true — the agent announces `action: "editing"` automatically.
+     */
+    announceOnExecute?: boolean;
+}
+export declare class Agent implements PresenceAnnouncer {
+    private readonly opts;
+    constructor(options: AgentOptions);
+    /**
+     * Build a long-lived agent session — caches `Ablo({kind:'agent'})`
+     * instances per `(org, user, surface, target)` and refreshes capability
+     * tokens before TTL elapses. Use on the server when the same agent
+     * identity handles many requests.
+     *
+     * Returns the cache, NOT an `Agent` instance: the long-lived path
+     * uses `Ablo({kind:'agent'})` over WebSocket, while the `Agent` class
+     * itself is the short-lived REST helper for AI SDK tool loops. The
+     * static method lives here so consumers reach for everything
+     * agent-related under one namespace.
+     *
+     * ```ts
+     * const session = Agent.session({ syncServerUrl, schema, issueToken });
+     * const ablo = await session.getAgent({ userId, organizationId, surfaceClass });
+     * ```
+     */
+    static session: typeof createAgentSession;
+    /** The fully-qualified userId used on the wire: `agent:<agentId>`. */
+    get userId(): string;
+    /**
+     * Extract the Agent instance from an AI SDK tool's
+     * `experimental_context`. Use inside tool `execute` functions to reach
+     * the perception without closure-capturing it.
+     *
+     * ```ts
+     * execute: async (args, { experimental_context }) => {
+     *   const perception = Agent.fromContext(experimental_context);
+     *   const check = await perception.checkFreshness('Slide', args.id, lastSeenAt);
+     *   // ...
+     * }
+     * ```
+     *
+     * Throws if the context is missing or doesn't contain an Agent.
+     * @param ctx The `experimental_context` passed to the tool.
+     * @param toolName Optional tool name for error messages.
+     */
+    static fromContext(ctx: unknown, toolName?: string): Agent;
+    /**
+     * Narrower variant of {@link fromContext} that returns `undefined` instead
+     * of throwing when perception isn't in context. Useful for tools where
+     * awareness is optional (e.g., read-only tools that work without it).
+     */
+    static tryFromContext(ctx: unknown): Agent | undefined;
+    /**
+     * Announce this agent's presence/activity. Fire-and-forget — logs errors
+     * but never throws (presence failures must not block the agent loop).
+     *
+     * If a `announcer` was provided (e.g. a connected SyncAgent), routes
+     * through it to reuse the WebSocket. Otherwise falls back to REST POST.
+     */
+    announce(status: 'online' | 'away' | 'offline', activity?: Activity): Promise<void>;
+    /**
+     * Gather a snapshot of current activity by peers and format it as
+     * natural-language context for injection into the next LLM prompt.
+     */
+    gather(options?: GatherOptions): Promise<GatherResult>;
+    /**
+     * Check if an entity was modified since `lastSeenAt`. Use before
+     * executing a mutation to detect stale state.
+     *
+     * Returns `{ stale: true, summary }` when the entity changed — feed
+     * `summary` back to the LLM as a tool result so it can adjust its plan.
+     */
+    checkFreshness(entityType: string, entityId: string, lastSeenAt: number): Promise<FreshnessCheck>;
+    /**
+     * Pull the org's presence, filter to intents targeting the given
+     * entity (self-intents excluded). Advisory — returns empty on any
+     * error so `checkFreshness` stays usable when the presence endpoint
+     * is down. Case-insensitive match on entityType + entityId to absorb
+     * PascalCase / lowercase divergence.
+     */
+    private fetchPendingIntentsFor;
+    /**
+     * Build a `prepareStep` hook for AI SDK's generateText / streamText /
+     * ToolLoopAgent. Called before each step — injects a system message
+     * summarizing what other agents are doing right now.
+     *
+     * ```ts
+     * const result = await generateText({
+     *   // ...
+     *   prepareStep: perception.prepareStep({ maxChars: 1500 }),
+     * });
+     * ```
+     */
+    prepareStep<M extends AgentMessage = AgentMessage>(options?: PrepareStepOptions): (ctx: PrepareStepContext<M>) => Promise<PrepareStepResult<M> | undefined>;
+    /**
+     * Build an `onStepFinish` hook for AI SDK. Called after each step —
+     * announces the agent's activity based on the tool calls that just ran.
+     *
+     * ```ts
+     * const result = await generateText({
+     *   // ...
+     *   onStepFinish: perception.onStepFinish(),
+     * });
+     * ```
+     */
+    onStepFinish(options?: OnStepFinishOptions): (ctx: StepFinishContext) => Promise<void>;
+    /**
+     * Wrap an AI SDK tool to check entity freshness before executing. If the
+     * entity was modified by another actor since the LLM last saw it, returns
+     * a diff summary as the tool result instead of executing — the LLM adjusts
+     * its plan rather than blindly overwriting.
+     *
+     * ```ts
+     * tools: {
+     *   updateSlide: perception.wrapTool(
+     *     tool({ inputSchema: ..., execute: ... }),
+     *     { entityType: 'Slide', getEntityId: (args) => args.id },
+     *   ),
+     * }
+     * ```
+     */
+    wrapTool<TArgs, TResult, TTool extends AgentTool<TArgs, TResult>>(originalTool: TTool, config: WrapToolOptions<TArgs>): TTool;
+    private fetchPresence;
+    private formatPrompt;
+    private request;
+}
+export declare namespace Agent {
+    type Options = AgentOptions;
+    type Context = AgentContext;
+    type SessionOptions = import('./session.js').AgentSessionOptions;
+}