@fenixforce/kernel 0.1.0

package/dist/events/session-manager.d.ts

@@ -0,0 +1,59 @@
+import type { AgentEvent } from "./types.js";
+import type { EventBus } from "./bus.js";
+export type EventListener = (event: AgentEvent) => void;
+export interface Session {
+    id: string;
+    createdAt: number;
+    events: AgentEvent[];
+    listeners: Set<EventListener>;
+}
+export interface SessionManagerConfig {
+    /** Buffer TTL in milliseconds (default: 30 minutes) */
+    bufferTtlMs?: number;
+    /** Max events to buffer per session (default: 10000) */
+    maxBufferSize?: number;
+}
+/**
+ * Manages sessions with event buffering for reconnection.
+ *
+ * Each session keeps a ring buffer of events. When a client
+ * reconnects (new WebSocket, SSE, or Telegram poll), it calls
+ * `replay()` to receive all buffered events, then `subscribe()`
+ * for live events going forward.
+ *
+ * Sessions auto-expire after `bufferTtlMs` of inactivity.
+ */
+export declare class SessionManager {
+    private sessions;
+    private timers;
+    private readonly bufferTtlMs;
+    private readonly maxBufferSize;
+    constructor(config?: SessionManagerConfig);
+    /** Create a new session. */
+    create(id?: string): Session;
+    /** Get a session by ID. */
+    get(id: string): Session | undefined;
+    /** Subscribe to live events for a session. Returns unsubscribe function. */
+    subscribe(id: string, listener: EventListener): () => void;
+    /** Buffer an event for a session and notify live listeners. */
+    bufferEvent(sessionId: string, event: AgentEvent): Promise<void>;
+    /**
+     * Replay all buffered events to a listener (for reconnection).
+     * Returns the count of replayed events.
+     */
+    replay(sessionId: string, listener: EventListener): number;
+    /**
+     * Wire this session manager to an EventBus for automatic buffering.
+     * Only buffers events whose sessionId matches.
+     * Returns an unsubscribe function.
+     */
+    connectBus(bus: EventBus, sessionId: string): () => void;
+    /** Delete a session and clean up its timer. */
+    delete(id: string): boolean;
+    /** Number of active sessions. */
+    get size(): number;
+    /** Clean up all sessions and timers. */
+    destroy(): void;
+    private resetTtl;
+    private clearTtl;
+}

package/dist/events/stream-adapter.d.ts

@@ -0,0 +1,24 @@
+import type { AgentEvent } from "./types.js";
+import type { EventBus } from "./bus.js";
+export interface StreamAdapterConfig {
+    /** Event bus to emit events to */
+    bus: EventBus;
+    /** Callback when the stream completes normally */
+    onComplete?: () => void;
+    /** Callback when the stream throws an error */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Pipe an async iterable of AgentEvents into an EventBus.
+ *
+ * Consumes the iterable sequentially, emitting each event.
+ * On error, emits an `error` event so subscribers are notified,
+ * then calls the onError callback.
+ */
+export declare function pipeToEventBus(stream: AsyncIterable<AgentEvent>, config: StreamAdapterConfig): Promise<void>;
+/**
+ * Collect all events from an async iterable into an array.
+ * Useful for testing — returns the full event list after
+ * the stream completes.
+ */
+export declare function collectEvents(stream: AsyncIterable<AgentEvent>): Promise<AgentEvent[]>;

package/dist/events/types.d.ts

@@ -0,0 +1,465 @@
+export type { CompletionParams, CompletionResult, ProviderCapabilities, ToolCall, } from "../providers/interface.js";
+export type { TokenUsage } from "../providers/stream-wrapper.js";
+export type { CostRecord } from "../providers/cost-tracking.js";
+export type { JobStatus, JobPriority, JobOptions, Job, } from "../../src/job-queue.js";
+export type AgentMode = "conversation" | "task" | "code" | "research" | "voice" | "passive";
+export interface AgentInput {
+    text?: string;
+    audioUrl?: string;
+    images?: string[];
+    attachments?: Array<{
+        name: string;
+        mimeType: string;
+        url: string;
+    }>;
+}
+export interface AgentContext {
+    sessionId: string;
+    mode: AgentMode;
+    turnNumber: number;
+    tokenBudget: number;
+    tokensUsed: number;
+    activeTools: string[];
+    workspaceId?: string;
+}
+export type TaskItemStatus = "pending" | "in_progress" | "done" | "blocked";
+export interface TaskItem {
+    id: string;
+    title: string;
+    status: TaskItemStatus;
+    subtasks?: TaskItem[];
+    verification?: QualityCheck;
+}
+export interface TaskTracker {
+    readonly tasks: readonly TaskItem[];
+    add(title: string): TaskItem;
+    update(id: string, status: TaskItemStatus): void;
+    current(): TaskItem | undefined;
+}
+export interface QualityCheck {
+    passed: boolean;
+    checks: Array<{
+        name: string;
+        passed: boolean;
+        message?: string;
+    }>;
+    timestamp: number;
+}
+export interface StreamChunk {
+    content: string;
+    index: number;
+    finishReason: string | null;
+}
+export interface ContentSource {
+    id: string;
+    type: "url" | "file" | "text" | "pdf" | "image";
+    uri: string;
+    mimeType?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ContentChunk {
+    id: string;
+    sourceId: string;
+    text: string;
+    index: number;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+}
+export interface ContentSearchResult {
+    chunk: ContentChunk;
+    score: number;
+    highlights?: string[];
+}
+export type BlockType = "text" | "code" | "citation" | "image" | "thinking" | "tool_call" | "tool_result" | "error";
+export interface Block {
+    id: string;
+    type: BlockType;
+    data: unknown;
+    createdAt: number;
+}
+export interface BlockPatch {
+    op: "replace" | "append" | "remove";
+    path: string;
+    value?: unknown;
+}
+export interface QueryClassification {
+    intent: "factual" | "creative" | "analytical" | "conversational" | "code" | "search";
+    confidence: number;
+    entities?: string[];
+    language?: string;
+}
+export interface StructuredOutputSchema {
+    type: "object" | "array";
+    properties?: Record<string, {
+        type: string;
+        description?: string;
+    }>;
+    required?: string[];
+    items?: StructuredOutputSchema;
+}
+export type EventUrgency = "immediate" | "soon" | "later";
+export interface AgentEventMeta {
+    /** Delivery urgency: immediate (process now), soon (next tick), later (when idle). */
+    urgency?: EventUrgency;
+    /** Priority within same urgency tier. 0 = lowest, 10 = highest. */
+    priority?: number;
+}
+interface BaseEvent extends AgentEventMeta {
+    timestamp: number;
+    sessionId?: string;
+}
+export interface AgentStartEvent extends BaseEvent {
+    type: "agent:start";
+    mode: AgentMode;
+    input: AgentInput;
+}
+export interface ContextBuiltEvent extends BaseEvent {
+    type: "context:built";
+    tokenCount: number;
+    messageCount: number;
+}
+export interface ContextOverflowEvent extends BaseEvent {
+    type: "context:overflow";
+    tokensUsed: number;
+    tokenBudget: number;
+}
+export interface ContextTruncatingEvent extends BaseEvent {
+    type: "context:truncating";
+    beforeTokens: number;
+    afterTokens: number;
+    strategy: string;
+}
+export interface TokenEvent extends BaseEvent {
+    type: "token";
+    content: string;
+    index: number;
+}
+export interface ToolStartEvent extends BaseEvent {
+    type: "tool:start";
+    toolName: string;
+    arguments: Record<string, unknown>;
+    callId: string;
+}
+export interface ToolResultEvent extends BaseEvent {
+    type: "tool:result";
+    toolName: string;
+    callId: string;
+    result?: unknown;
+    error?: string;
+    durationMs: number;
+}
+export interface ResponseFinalEvent extends BaseEvent {
+    type: "response:final";
+    content: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    finishReason: string | null;
+}
+export interface AgentEndEvent extends BaseEvent {
+    type: "agent:end";
+    reason: "complete" | "error" | "cancelled" | "timeout";
+    totalTurns: number;
+    totalTokens: number;
+}
+export interface LoopWarningEvent extends BaseEvent {
+    type: "loop:warning";
+    turnCount: number;
+    pattern: string;
+}
+export interface LoopBlockedEvent extends BaseEvent {
+    type: "loop:blocked";
+    turnCount: number;
+    reason: string;
+}
+export interface SessionCompactedEvent extends BaseEvent {
+    type: "session:compacted";
+    beforeTokens: number;
+    afterTokens: number;
+    droppedMessages: number;
+}
+export interface WrapupCompleteEvent extends BaseEvent {
+    type: "wrapup:complete";
+    summary: string;
+}
+export interface ModeChangedEvent extends BaseEvent {
+    type: "mode:changed";
+    from: AgentMode;
+    to: AgentMode;
+    reason: string;
+}
+export interface TaskPlannedEvent extends BaseEvent {
+    type: "task:planned";
+    tasks: TaskItem[];
+}
+export interface TaskUpdatedEvent extends BaseEvent {
+    type: "task:updated";
+    taskId: string;
+    status: TaskItemStatus;
+    title: string;
+}
+export interface VerificationResultEvent extends BaseEvent {
+    type: "verification:result";
+    taskId: string;
+    check: QualityCheck;
+}
+export interface CostTrackedEvent extends BaseEvent {
+    type: "cost:tracked";
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCost: number;
+}
+export interface ProviderCircuitOpenEvent extends BaseEvent {
+    type: "provider:circuit:open";
+    provider: string;
+    failureCount: number;
+    cooldownMs: number;
+}
+export interface ProviderCircuitHalfopenEvent extends BaseEvent {
+    type: "provider:circuit:halfopen";
+    provider: string;
+}
+export interface ProviderCircuitClosedEvent extends BaseEvent {
+    type: "provider:circuit:closed";
+    provider: string;
+}
+export interface QuotaWarningEvent extends BaseEvent {
+    type: "quota:warning";
+    provider: string;
+    usagePercent: number;
+    remainingTokens?: number;
+}
+export interface QuotaExceededEvent extends BaseEvent {
+    type: "quota:exceeded";
+    provider: string;
+    limit: number;
+}
+export interface ApprovalRequestedEvent extends BaseEvent {
+    type: "approval:requested";
+    toolName: string;
+    callId: string;
+    arguments: Record<string, unknown>;
+}
+export interface ApprovalGrantedEvent extends BaseEvent {
+    type: "approval:granted";
+    callId: string;
+}
+export interface ApprovalDeniedEvent extends BaseEvent {
+    type: "approval:denied";
+    callId: string;
+    reason?: string;
+}
+export interface SSRFBlockedEvent extends BaseEvent {
+    type: "ssrf:blocked";
+    url: string;
+    resolvedIp?: string;
+}
+export interface ShellBleedDetectedEvent extends BaseEvent {
+    type: "shell-bleed:detected";
+    command: string;
+    pattern: string;
+}
+export interface MemoryExtractedEvent extends BaseEvent {
+    type: "memory:extracted";
+    facts: string[];
+    sourceMessageId?: string;
+}
+export interface MemoryConsolidatedEvent extends BaseEvent {
+    type: "memory:consolidated";
+    mergedCount: number;
+    prunedCount: number;
+}
+export interface MemorySavedImmediateEvent extends BaseEvent {
+    type: "memory:saved-immediate";
+    key: string;
+    value: string;
+}
+export interface ObservationCapturedEvent extends BaseEvent {
+    type: "observation:captured";
+    observation: string;
+    confidence: number;
+}
+export interface ObservationThresholdExceededEvent extends BaseEvent {
+    type: "observation:threshold-exceeded";
+    observation: string;
+    count: number;
+    threshold: number;
+}
+export interface VoiceSTTStartEvent extends BaseEvent {
+    type: "voice:stt:start";
+    audioUrl: string;
+}
+export interface VoiceSTTCompleteEvent extends BaseEvent {
+    type: "voice:stt:complete";
+    transcript: string;
+    confidence: number;
+    durationMs: number;
+}
+export interface VoiceTTSStartEvent extends BaseEvent {
+    type: "voice:tts:start";
+    text: string;
+}
+export interface VoiceTTSChunkEvent extends BaseEvent {
+    type: "voice:tts:chunk";
+    audioData: Uint8Array | string;
+    index: number;
+}
+export interface VoiceTTSCompleteEvent extends BaseEvent {
+    type: "voice:tts:complete";
+    durationMs: number;
+    charCount: number;
+}
+export interface VoiceSidecarStartedEvent extends BaseEvent {
+    type: "voice:sidecar:started";
+    provider: string;
+    endpoint: string;
+}
+export interface VoiceSidecarCrashedEvent extends BaseEvent {
+    type: "voice:sidecar:crashed";
+    provider: string;
+    error: string;
+    restartAttempt: number;
+}
+export interface VoiceBargeInEvent extends BaseEvent {
+    type: "voice:barge-in";
+    spokenText: string;
+    pendingText: string;
+    turnNumber: number;
+}
+export interface VoiceSpeakerDetectedEvent extends BaseEvent {
+    type: "voice:speaker:detected";
+    speakerId: string;
+    isKnown: boolean;
+    label?: string;
+}
+export interface VoiceTurnEndEvent extends BaseEvent {
+    type: "voice:turn:end";
+    preset: string;
+    silenceDurationMs: number;
+    speakerId?: string;
+}
+export interface VoiceIntelligenceReadyEvent extends BaseEvent {
+    type: "voice:intelligence:ready";
+    features: string[];
+    jobId?: string;
+}
+export interface ErrorEvent extends BaseEvent {
+    type: "error";
+    error: string;
+    code?: string;
+    recoverable: boolean;
+}
+export interface ExtensionFiredEvent extends BaseEvent {
+    type: "extension:fired";
+    extensionId: string;
+    hook: string;
+    durationMs?: number;
+}
+export interface JobEnqueuedEvent extends BaseEvent {
+    type: "job:enqueued";
+    jobId: string;
+    jobType: string;
+    jobPriority: string;
+}
+export interface JobStartedEvent extends BaseEvent {
+    type: "job:started";
+    jobId: string;
+    jobType: string;
+}
+export interface JobCompletedEvent extends BaseEvent {
+    type: "job:completed";
+    jobId: string;
+    jobType: string;
+    result: unknown;
+}
+export interface JobFailedEvent extends BaseEvent {
+    type: "job:failed";
+    jobId: string;
+    jobType: string;
+    error: string;
+    attempt: number;
+    maxRetries: number;
+}
+export interface JobDeadEvent extends BaseEvent {
+    type: "job:dead";
+    jobId: string;
+    jobType: string;
+    totalAttempts: number;
+}
+export interface ContentIngestingEvent extends BaseEvent {
+    type: "content:ingesting";
+    sourceId: string;
+    stage: string;
+    progress: number;
+}
+export interface ContentReadyEvent extends BaseEvent {
+    type: "content:ready";
+    sourceId: string;
+    chunks: number;
+    wordCount: number;
+}
+export interface ContentErrorEvent extends BaseEvent {
+    type: "content:error";
+    sourceId: string;
+    stage: string;
+    error: string;
+}
+export interface OCRProcessingEvent extends BaseEvent {
+    type: "ocr:processing";
+    sourceId: string;
+    pageNumber: number;
+    totalPages: number;
+}
+export interface RetrievalTreeStepEvent extends BaseEvent {
+    type: "retrieval:tree_step";
+    nodePath: string;
+    decision: string;
+    outcome: string;
+}
+export interface SidecarCooldownEvent extends BaseEvent {
+    type: "sidecar:cooldown";
+    provider: string;
+    cooldownUntil: number;
+    attempts: number;
+}
+export interface InterventionRequestedEvent extends BaseEvent {
+    type: "intervention:requested";
+    messageId: string;
+    handler: string;
+}
+export interface InterventionResultEvent extends BaseEvent {
+    type: "intervention:result";
+    messageId: string;
+    action: "approve" | "deny" | "modify" | "skip";
+}
+export interface BlockEmittedEvent extends BaseEvent {
+    type: "block:emitted";
+    blockId: string;
+    blockType: BlockType;
+    data: unknown;
+}
+export interface BlockUpdatedEvent extends BaseEvent {
+    type: "block:updated";
+    blockId: string;
+    patch: BlockPatch;
+}
+export interface SessionReconnectedEvent extends BaseEvent {
+    type: "session:reconnected";
+    reconnectedSessionId: string;
+    replayedEventCount: number;
+}
+export interface QueryClassifiedEvent extends BaseEvent {
+    type: "query:classified";
+    queryId: string;
+    classification: QueryClassification;
+    standaloneQuery: string;
+    skipAgent: boolean;
+}
+export type AgentEvent = AgentStartEvent | ContextBuiltEvent | ContextOverflowEvent | ContextTruncatingEvent | TokenEvent | ToolStartEvent | ToolResultEvent | ResponseFinalEvent | AgentEndEvent | LoopWarningEvent | LoopBlockedEvent | SessionCompactedEvent | WrapupCompleteEvent | ModeChangedEvent | TaskPlannedEvent | TaskUpdatedEvent | VerificationResultEvent | CostTrackedEvent | ProviderCircuitOpenEvent | ProviderCircuitHalfopenEvent | ProviderCircuitClosedEvent | QuotaWarningEvent | QuotaExceededEvent | ApprovalRequestedEvent | ApprovalGrantedEvent | ApprovalDeniedEvent | SSRFBlockedEvent | ShellBleedDetectedEvent | MemoryExtractedEvent | MemoryConsolidatedEvent | MemorySavedImmediateEvent | ObservationCapturedEvent | ObservationThresholdExceededEvent | VoiceSTTStartEvent | VoiceSTTCompleteEvent | VoiceTTSStartEvent | VoiceTTSChunkEvent | VoiceTTSCompleteEvent | VoiceSidecarStartedEvent | VoiceSidecarCrashedEvent | VoiceBargeInEvent | VoiceSpeakerDetectedEvent | VoiceTurnEndEvent | VoiceIntelligenceReadyEvent | ErrorEvent | ExtensionFiredEvent | JobEnqueuedEvent | JobStartedEvent | JobCompletedEvent | JobFailedEvent | JobDeadEvent | ContentIngestingEvent | ContentReadyEvent | ContentErrorEvent | OCRProcessingEvent | RetrievalTreeStepEvent | SidecarCooldownEvent | InterventionRequestedEvent | InterventionResultEvent | BlockEmittedEvent | BlockUpdatedEvent | SessionReconnectedEvent | QueryClassifiedEvent;
+export type EventOfType<T extends AgentEvent["type"]> = Extract<AgentEvent, {
+    type: T;
+}>;
+export type AgentEventType = AgentEvent["type"];

package/dist/events/websocket.d.ts

@@ -0,0 +1,34 @@
+import type { AgentEvent } from "./types.js";
+import type { EventBus } from "./bus.js";
+export type WebSocketChannel = "agent" | "workspace";
+export interface WebSocketMessage {
+    channel: WebSocketChannel;
+    event: AgentEvent;
+    sequence: number;
+}
+/** Minimal sender abstraction — works with any WebSocket implementation. */
+export interface WebSocketSender {
+    send(message: WebSocketMessage): void;
+    close(): void;
+    readonly readyState: number;
+}
+export interface DualWebSocketConfig {
+    /** Event bus to subscribe to */
+    bus: EventBus;
+    /** Sender for the agent channel (per-session events) */
+    agentSender: WebSocketSender;
+    /** Sender for the workspace channel (cross-session events) */
+    workspaceSender: WebSocketSender;
+    /** Event types routed to workspace channel (rest go to agent) */
+    workspaceEvents?: Set<string>;
+}
+/**
+ * Set up dual WebSocket channels.
+ *
+ * Events are routed by type:
+ * - Workspace events (jobs, costs, provider status) → workspace channel
+ * - Everything else → agent channel
+ *
+ * Returns a teardown function that unsubscribes and closes both senders.
+ */
+export declare function setupDualWebSocket(config: DualWebSocketConfig): () => void;

package/dist/extensions/defaults/05-session-repair.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: session repair (priority 05).
+ * Wraps repairSession() to fix corrupted message arrays.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerSessionRepair(mgr: ExtensionManager): void;

package/dist/extensions/defaults/10-logging.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: event logging (priority 10).
+ * Logs every agent event to console in debug mode.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerLogging(mgr: ExtensionManager): void;

package/dist/extensions/defaults/15-loop-guard.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: loop guard (priority 15).
+ * Wraps LoopGuard.check() to detect stuck tool-call patterns.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerLoopGuard(mgr: ExtensionManager, maxTotal?: number): void;

package/dist/extensions/defaults/20-cost-tracking.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default extension: cost tracking (priority 20).
+ * Wraps CostMeter.track() to persist token usage after calls.
+ */
+import type { ExtensionManager } from "../manager.js";
+import type { CostMeter } from "../../providers/cost-meter.js";
+export declare function registerCostTracking(mgr: ExtensionManager, meter: CostMeter): void;

package/dist/extensions/defaults/25-ssrf-protection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: SSRF protection (priority 25).
+ * Wraps validateUrl() to block private-IP and metadata URLs.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerSsrfProtection(mgr: ExtensionManager): void;

package/dist/extensions/defaults/30-rate-limiting.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: rate limiting (priority 30).
+ * Simple in-memory sliding-window rate limiter.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerRateLimiting(mgr: ExtensionManager, windowMs?: number, maxRequests?: number): void;

package/dist/extensions/defaults/35-shell-bleed.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: shell bleed detection (priority 35).
+ * Wraps detectShellBleed() to scan scripts for env var leaks.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerShellBleed(mgr: ExtensionManager): void;

package/dist/extensions/defaults/40-observation-capture.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default extension: observation capture (priority 40).
+ * Wraps checkObservationThresholds() for review detection.
+ */
+import type { ExtensionManager } from "../manager.js";
+import type { StorageAdapter } from "../../storage/interface.js";
+export declare function registerObservationCapture(mgr: ExtensionManager, storage: StorageAdapter): void;

package/dist/extensions/defaults/45-context-survival.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: context survival / compaction (priority 45).
+ * Wraps shouldCompact + sessionCompact for automatic trimming.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerContextSurvival(mgr: ExtensionManager): void;

package/dist/extensions/defaults/50-context-budget.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default extension: context budget (priority 50).
+ * Wraps allocateBudget + truncateToTokenBudget for prompt sizing.
+ */
+import type { ExtensionManager } from "../manager.js";
+export declare function registerContextBudget(mgr: ExtensionManager): void;

package/dist/extensions/defaults/55-steering-rules.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default extension: steering rules (priority 55).
+ * Wraps resolveRules() to filter rules for current context.
+ */
+import type { ExtensionManager } from "../manager.js";
+import type { SteeringRuleSet } from "../../config/steering-rules.js";
+export declare function registerSteeringRules(mgr: ExtensionManager, ruleSet: SteeringRuleSet): void;

package/dist/extensions/defaults/60-quality-gates.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default extension: quality gates (priority 60).
+ * Wraps qualityGates() to run verification checks before completion.
+ */
+import type { ExtensionManager } from "../manager.js";
+import type { TaskTracker } from "../../events/types.js";
+export declare function registerQualityGates(mgr: ExtensionManager, _tracker: TaskTracker, _sessionId: string): void;