@reactive-agents/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @reactive-agents/core
+
+Core services and types for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Provides the foundational building blocks that all other packages depend on: the EventBus, AgentService, TaskService, and shared schemas.
+
+## Installation
+
+```bash
+bun add @reactive-agents/core effect
+```
+
+Or install everything at once:
+
+```bash
+bun add reactive-agents effect
+```
+
+## What's Included
+
+| Export | Description |
+|--------|-------------|
+| `EventBusLive` | Publish/subscribe event bus layer |
+| `AgentServiceLive` | Create and manage agent instances |
+| `TaskServiceLive` | Create, track, and cancel tasks |
+| `CoreServicesLive` | Composite layer wiring all three above |
+| `AgentId`, `TaskId` | Branded ID types |
+| `AgentConfig`, `TaskInput` | Validated schemas |
+| `AgentError`, `TaskError` | Tagged error types |
+
+## Usage
+
+```typescript
+import { Effect } from "effect";
+import { CoreServicesLive, AgentService } from "@reactive-agents/core";
+
+const program = Effect.gen(function* () {
+  const agents = yield* AgentService;
+  const agent = yield* agents.create({ name: "my-agent", capabilities: [] });
+  return agent;
+});
+
+const result = await Effect.runPromise(
+  program.pipe(Effect.provide(CoreServicesLive))
+);
+```
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts](https://tylerjrbuell.github.io/reactive-agents-ts/)

package/dist/index.d.ts

@@ -0,0 +1,421 @@
+import { Schema, Context, Effect, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+
+declare const AgentId: Schema.brand<typeof Schema.String, "AgentId">;
+type AgentId = typeof AgentId.Type;
+declare const CapabilityType: Schema.Literal<["tool", "skill", "reasoning", "memory"]>;
+type CapabilityType = typeof CapabilityType.Type;
+declare const CapabilitySchema: Schema.Struct<{
+    type: Schema.Literal<["tool", "skill", "reasoning", "memory"]>;
+    name: typeof Schema.String;
+}>;
+type Capability = typeof CapabilitySchema.Type;
+declare const ReasoningStrategy: Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>;
+type ReasoningStrategy = typeof ReasoningStrategy.Type;
+declare const MemoryType: Schema.Literal<["semantic", "episodic", "procedural", "working"]>;
+type MemoryType = typeof MemoryType.Type;
+declare const AgentSchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "AgentId">;
+    name: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    capabilities: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["tool", "skill", "reasoning", "memory"]>;
+        name: typeof Schema.String;
+    }>>;
+    config: typeof Schema.Unknown;
+    state: typeof Schema.Unknown;
+    createdAt: typeof Schema.DateFromSelf;
+    updatedAt: typeof Schema.DateFromSelf;
+}>;
+type Agent = typeof AgentSchema.Type;
+declare const AgentConfigSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    capabilities: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["tool", "skill", "reasoning", "memory"]>;
+        name: typeof Schema.String;
+    }>>;
+    config: Schema.optional<typeof Schema.Unknown>;
+    initialState: Schema.optional<typeof Schema.Unknown>;
+}>;
+type AgentConfig = typeof AgentConfigSchema.Type;
+
+declare const TaskId: Schema.brand<typeof Schema.String, "TaskId">;
+type TaskId = typeof TaskId.Type;
+declare const TaskType: Schema.Literal<["query", "action", "workflow", "research", "delegation"]>;
+type TaskType = typeof TaskType.Type;
+declare const Priority: Schema.Literal<["low", "medium", "high", "critical"]>;
+type Priority = typeof Priority.Type;
+declare const TaskStatus: Schema.Literal<["pending", "running", "paused", "completed", "failed", "cancelled"]>;
+type TaskStatus = typeof TaskStatus.Type;
+declare const TaskMetadataSchema: Schema.Struct<{
+    maxDuration: Schema.optional<typeof Schema.Number>;
+    maxCost: Schema.optional<typeof Schema.Number>;
+    requiresApproval: Schema.optional<typeof Schema.Boolean>;
+    tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    context: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+type TaskMetadata = typeof TaskMetadataSchema.Type;
+declare const TaskSchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "TaskId">;
+    agentId: Schema.brand<typeof Schema.String, "AgentId">;
+    type: Schema.Literal<["query", "action", "workflow", "research", "delegation"]>;
+    input: typeof Schema.Unknown;
+    priority: Schema.Literal<["low", "medium", "high", "critical"]>;
+    status: Schema.Literal<["pending", "running", "paused", "completed", "failed", "cancelled"]>;
+    metadata: Schema.Struct<{
+        maxDuration: Schema.optional<typeof Schema.Number>;
+        maxCost: Schema.optional<typeof Schema.Number>;
+        requiresApproval: Schema.optional<typeof Schema.Boolean>;
+        tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        context: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>;
+    createdAt: typeof Schema.DateFromSelf;
+    startedAt: Schema.optional<typeof Schema.DateFromSelf>;
+    completedAt: Schema.optional<typeof Schema.DateFromSelf>;
+}>;
+type Task = typeof TaskSchema.Type;
+declare const TaskConfigSchema: Schema.Struct<{
+    agentId: Schema.brand<typeof Schema.String, "AgentId">;
+    type: Schema.Literal<["query", "action", "workflow", "research", "delegation"]>;
+    input: typeof Schema.Unknown;
+    priority: Schema.optional<Schema.Literal<["low", "medium", "high", "critical"]>>;
+    metadata: Schema.optional<Schema.Struct<{
+        maxDuration: Schema.optional<typeof Schema.Number>;
+        maxCost: Schema.optional<typeof Schema.Number>;
+        requiresApproval: Schema.optional<typeof Schema.Boolean>;
+        tags: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        context: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>>;
+}>;
+type TaskConfig = typeof TaskConfigSchema.Type;
+
+declare const StepType: Schema.Literal<["thought", "action", "observation", "plan", "reflection", "critique"]>;
+type StepType = typeof StepType.Type;
+declare const ReasoningStepSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    type: Schema.Literal<["thought", "action", "observation", "plan", "reflection", "critique"]>;
+    content: typeof Schema.String;
+    timestamp: typeof Schema.DateFromSelf;
+    metadata: Schema.optional<Schema.Struct<{
+        confidence: Schema.optional<typeof Schema.Number>;
+        toolUsed: Schema.optional<typeof Schema.String>;
+        cost: Schema.optional<typeof Schema.Number>;
+        duration: Schema.optional<typeof Schema.Number>;
+    }>>;
+}>;
+type ReasoningStep = typeof ReasoningStepSchema.Type;
+declare const ResultMetadataSchema: Schema.Struct<{
+    duration: typeof Schema.Number;
+    cost: typeof Schema.Number;
+    tokensUsed: typeof Schema.Number;
+    confidence: Schema.optional<Schema.filter<typeof Schema.Number>>;
+    strategyUsed: Schema.optional<typeof Schema.String>;
+    stepsCount: Schema.optional<typeof Schema.Number>;
+}>;
+type ResultMetadata = typeof ResultMetadataSchema.Type;
+declare const TaskResultSchema: Schema.Struct<{
+    taskId: Schema.brand<typeof Schema.String, "TaskId">;
+    agentId: Schema.brand<typeof Schema.String, "AgentId">;
+    output: typeof Schema.Unknown;
+    success: typeof Schema.Boolean;
+    error: Schema.optional<typeof Schema.String>;
+    metadata: Schema.Struct<{
+        duration: typeof Schema.Number;
+        cost: typeof Schema.Number;
+        tokensUsed: typeof Schema.Number;
+        confidence: Schema.optional<Schema.filter<typeof Schema.Number>>;
+        strategyUsed: Schema.optional<typeof Schema.String>;
+        stepsCount: Schema.optional<typeof Schema.Number>;
+    }>;
+    completedAt: typeof Schema.DateFromSelf;
+}>;
+type TaskResult = typeof TaskResultSchema.Type;
+
+declare const MessageId: Schema.brand<typeof Schema.String, "MessageId">;
+type MessageId = typeof MessageId.Type;
+declare const MessageType: Schema.Literal<["request", "response", "notification", "delegation", "query"]>;
+type MessageType = typeof MessageType.Type;
+declare const MessageSchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "MessageId">;
+    fromAgentId: Schema.brand<typeof Schema.String, "AgentId">;
+    toAgentId: Schema.brand<typeof Schema.String, "AgentId">;
+    type: Schema.Literal<["request", "response", "notification", "delegation", "query"]>;
+    content: typeof Schema.Unknown;
+    timestamp: typeof Schema.DateFromSelf;
+    metadata: Schema.optional<Schema.Struct<{
+        correlationId: Schema.optional<typeof Schema.String>;
+        causationId: Schema.optional<typeof Schema.String>;
+        context: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>>;
+}>;
+type Message = typeof MessageSchema.Type;
+
+declare const LogLevel: Schema.Literal<["debug", "info", "warn", "error"]>;
+type LogLevel = typeof LogLevel.Type;
+declare const TelemetryConfigSchema: Schema.Struct<{
+    enabled: typeof Schema.Boolean;
+    endpoint: Schema.optional<typeof Schema.String>;
+    serviceName: typeof Schema.String;
+    sampleRate: Schema.filter<typeof Schema.Number>;
+}>;
+type TelemetryConfig = typeof TelemetryConfigSchema.Type;
+declare const RuntimeConfigSchema: Schema.Struct<{
+    maxConcurrentTasks: typeof Schema.Number;
+    taskTimeout: typeof Schema.Number;
+    maxRetries: typeof Schema.Number;
+    retryDelay: typeof Schema.Number;
+    logLevel: Schema.Literal<["debug", "info", "warn", "error"]>;
+    telemetry: Schema.Struct<{
+        enabled: typeof Schema.Boolean;
+        endpoint: Schema.optional<typeof Schema.String>;
+        serviceName: typeof Schema.String;
+        sampleRate: Schema.filter<typeof Schema.Number>;
+    }>;
+}>;
+type RuntimeConfig = typeof RuntimeConfigSchema.Type;
+declare const defaultRuntimeConfig: RuntimeConfig;
+declare const ContextControllerSchema: Schema.Struct<{
+    prioritization: Schema.optional<Schema.Literal<["semantic", "recency", "importance"]>>;
+    pruning: Schema.optional<Schema.Literal<["adaptive", "sliding-window", "fifo"]>>;
+    retention: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    compression: Schema.optional<Schema.Literal<["none", "aggressive", "adaptive"]>>;
+}>;
+type ContextController = typeof ContextControllerSchema.Type;
+declare const CircuitBreakerConfigSchema: Schema.Struct<{
+    errorThreshold: Schema.filter<typeof Schema.Number>;
+    timeout: typeof Schema.Number;
+    resetTimeout: typeof Schema.Number;
+}>;
+type CircuitBreakerConfig = typeof CircuitBreakerConfigSchema.Type;
+declare const TokenBudgetConfigSchema: Schema.Struct<{
+    total: typeof Schema.Number;
+    allocation: Schema.optional<Schema.Struct<{
+        system: Schema.optional<typeof Schema.Number>;
+        context: Schema.optional<typeof Schema.Number>;
+        reasoning: Schema.optional<typeof Schema.Number>;
+        output: Schema.optional<typeof Schema.Number>;
+    }>>;
+    enforcement: Schema.Literal<["hard", "soft"]>;
+}>;
+type TokenBudgetConfig = typeof TokenBudgetConfigSchema.Type;
+declare const UncertaintySignalSchema: Schema.Struct<{
+    taskId: typeof Schema.String;
+    agentId: typeof Schema.String;
+    confidence: typeof Schema.Number;
+    phase: typeof Schema.String;
+    context: typeof Schema.String;
+}>;
+type UncertaintySignal = typeof UncertaintySignalSchema.Type;
+declare const AgentDecisionSchema: Schema.Struct<{
+    type: Schema.Literal<["tool_call", "strategy_switch", "output"]>;
+    importance: typeof Schema.Number;
+    content: typeof Schema.Unknown;
+}>;
+type AgentDecision = typeof AgentDecisionSchema.Type;
+
+declare const AgentError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "AgentError";
+} & Readonly<A>;
+/**
+ * Base agent error — catch-all for unexpected agent failures.
+ */
+declare class AgentError extends AgentError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const AgentNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "AgentNotFoundError";
+} & Readonly<A>;
+/**
+ * Agent not found in registry.
+ */
+declare class AgentNotFoundError extends AgentNotFoundError_base<{
+    readonly agentId: string;
+    readonly message: string;
+}> {
+}
+declare const TaskError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "TaskError";
+} & Readonly<A>;
+/**
+ * Task execution failure.
+ */
+declare class TaskError extends TaskError_base<{
+    readonly taskId: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ValidationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ValidationError";
+} & Readonly<A>;
+/**
+ * Schema validation failure.
+ */
+declare class ValidationError extends ValidationError_base<{
+    readonly field: string;
+    readonly message: string;
+    readonly value?: unknown;
+}> {
+}
+declare const RuntimeError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "RuntimeError";
+} & Readonly<A>;
+/**
+ * Runtime failure (fiber crash, timeout, etc.).
+ */
+declare class RuntimeError extends RuntimeError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+
+type AgentEvent = {
+    readonly _tag: "TaskCreated";
+    readonly taskId: string;
+} | {
+    readonly _tag: "TaskCompleted";
+    readonly taskId: string;
+    readonly success: boolean;
+} | {
+    readonly _tag: "TaskFailed";
+    readonly taskId: string;
+    readonly error: string;
+} | {
+    readonly _tag: "AgentCreated";
+    readonly agentId: string;
+} | {
+    readonly _tag: "MessageSent";
+    readonly message: Message;
+} | {
+    readonly _tag: "ExecutionPhaseEntered";
+    readonly taskId: string;
+    readonly phase: string;
+} | {
+    readonly _tag: "ExecutionHookFired";
+    readonly taskId: string;
+    readonly phase: string;
+    readonly timing: string;
+} | {
+    readonly _tag: "ExecutionLoopIteration";
+    readonly taskId: string;
+    readonly iteration: number;
+} | {
+    readonly _tag: "ExecutionCancelled";
+    readonly taskId: string;
+} | {
+    readonly _tag: "MemoryBootstrapped";
+    readonly agentId: string;
+    readonly tier: string;
+} | {
+    readonly _tag: "MemoryFlushed";
+    readonly agentId: string;
+} | {
+    readonly _tag: "MemorySnapshotSaved";
+    readonly agentId: string;
+    readonly sessionId: string;
+} | {
+    readonly _tag: "Custom";
+    readonly type: string;
+    readonly payload: unknown;
+};
+type EventHandler = (event: AgentEvent) => Effect.Effect<void, never>;
+declare const EventBus_base: Context.TagClass<EventBus, "EventBus", {
+    /** Publish an event to all subscribers. */
+    readonly publish: (event: AgentEvent) => Effect.Effect<void, never>;
+    /** Subscribe a handler for all events. Returns unsubscribe function. */
+    readonly subscribe: (handler: EventHandler) => Effect.Effect<() => void, never>;
+    /** Subscribe only to events matching a tag. */
+    readonly on: (tag: AgentEvent["_tag"], handler: EventHandler) => Effect.Effect<() => void, never>;
+}>;
+declare class EventBus extends EventBus_base {
+}
+declare const EventBusLive: Layer.Layer<EventBus, never, never>;
+
+declare const AgentService_base: Context.TagClass<AgentService, "AgentService", {
+    /** Create a new agent from config. */
+    readonly create: (config: AgentConfig) => Effect.Effect<Agent, AgentError>;
+    /** Retrieve an agent by ID. */
+    readonly get: (id: AgentId) => Effect.Effect<Agent, AgentNotFoundError>;
+    /** List all registered agents. */
+    readonly list: () => Effect.Effect<readonly Agent[], never>;
+    /** Delete an agent by ID. */
+    readonly delete: (id: AgentId) => Effect.Effect<void, AgentNotFoundError>;
+}>;
+declare class AgentService extends AgentService_base {
+}
+declare const AgentServiceLive: Layer.Layer<AgentService, never, EventBus>;
+
+declare const TaskService_base: Context.TagClass<TaskService, "TaskService", {
+    /** Create a new task (status: pending). */
+    readonly create: (config: TaskConfig) => Effect.Effect<Task, TaskError>;
+    /** Get task by ID. */
+    readonly get: (id: TaskId) => Effect.Effect<Task, TaskError>;
+    /** Update task status. */
+    readonly updateStatus: (id: TaskId, status: Task["status"]) => Effect.Effect<Task, TaskError>;
+    /** Cancel a running task. */
+    readonly cancel: (id: TaskId) => Effect.Effect<void, TaskError>;
+}>;
+declare class TaskService extends TaskService_base {
+}
+declare const TaskServiceLive: Layer.Layer<TaskService, never, EventBus>;
+
+type TruncationStrategy = "drop-oldest" | "drop-middle" | "summarize-oldest";
+declare const ContextError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ContextError";
+} & Readonly<A>;
+declare class ContextError extends ContextError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ContextWindowManager_base: Context.TagClass<ContextWindowManager, "ContextWindowManager", {
+    /**
+     * Build a context-window-safe message array.
+     * Injects memory context as a system message and truncates if needed.
+     */
+    readonly buildContext: (options: {
+        systemPrompt: string;
+        messages: readonly unknown[];
+        memoryContext?: string;
+        maxTokens: number;
+        reserveOutputTokens: number;
+    }) => Effect.Effect<readonly unknown[], ContextError>;
+    /**
+     * Estimate token count for a string.
+     * Uses character-based heuristic (1 token ~ 4 chars) when no tokenizer available.
+     */
+    readonly estimateTokens: (text: string) => Effect.Effect<number, never>;
+    /**
+     * Check if a message array fits within the context limit.
+     */
+    readonly fitsInContext: (messages: readonly unknown[], maxTokens: number) => Effect.Effect<boolean, never>;
+    /**
+     * Truncate messages to fit within targetTokens.
+     */
+    readonly truncate: (messages: readonly unknown[], targetTokens: number, strategy: TruncationStrategy) => Effect.Effect<readonly unknown[], ContextError>;
+}>;
+declare class ContextWindowManager extends ContextWindowManager_base {
+}
+declare const ContextWindowManagerLive: Layer.Layer<ContextWindowManager, never, never>;
+
+/** Generate a new AgentId (ULID — sortable, globally unique). */
+declare const generateAgentId: () => AgentId;
+/** Generate a new TaskId. */
+declare const generateTaskId: () => TaskId;
+/** Generate a new MessageId. */
+declare const generateMessageId: () => MessageId;
+
+/**
+ * Complete core services layer.
+ * Provides: EventBus, AgentService, TaskService, ContextWindowManager
+ *
+ * Usage:
+ *   myProgram.pipe(Effect.provide(CoreServicesLive))
+ */
+declare const CoreServicesLive: Layer.Layer<AgentService | TaskService | ContextWindowManager, never, never>;
+
+export { type Agent, type AgentConfig, AgentConfigSchema, type AgentDecision, AgentDecisionSchema, AgentError, type AgentEvent, AgentId, AgentNotFoundError, AgentSchema, AgentService, AgentServiceLive, type Capability, CapabilitySchema, CapabilityType, type CircuitBreakerConfig, CircuitBreakerConfigSchema, type ContextController, ContextControllerSchema, ContextError, ContextWindowManager, ContextWindowManagerLive, CoreServicesLive, EventBus, EventBusLive, type EventHandler, LogLevel, MemoryType, type Message, MessageId, MessageSchema, MessageType, Priority, type ReasoningStep, ReasoningStepSchema, ReasoningStrategy, type ResultMetadata, ResultMetadataSchema, type RuntimeConfig, RuntimeConfigSchema, RuntimeError, StepType, type Task, type TaskConfig, TaskConfigSchema, TaskError, TaskId, type TaskMetadata, TaskMetadataSchema, type TaskResult, TaskResultSchema, TaskSchema, TaskService, TaskServiceLive, TaskStatus, TaskType, type TelemetryConfig, TelemetryConfigSchema, type TokenBudgetConfig, TokenBudgetConfigSchema, type TruncationStrategy, type UncertaintySignal, UncertaintySignalSchema, ValidationError, defaultRuntimeConfig, generateAgentId, generateMessageId, generateTaskId };

package/dist/index.js

@@ -0,0 +1,555 @@
+// src/types/agent.ts
+import { Schema } from "effect";
+var AgentId = Schema.String.pipe(Schema.brand("AgentId"));
+var CapabilityType = Schema.Literal(
+  "tool",
+  "skill",
+  "reasoning",
+  "memory"
+);
+var CapabilitySchema = Schema.Struct({
+  type: CapabilityType,
+  name: Schema.String
+});
+var ReasoningStrategy = Schema.Literal(
+  "reactive",
+  "plan-execute-reflect",
+  "tree-of-thought",
+  "reflexion",
+  "adaptive"
+);
+var MemoryType = Schema.Literal(
+  "semantic",
+  // Long-term knowledge (SQLite + memory.md)
+  "episodic",
+  // Daily logs + session snapshots
+  "procedural",
+  // Learned workflows and patterns
+  "working"
+  // In-process Ref, capacity 7
+);
+var AgentSchema = Schema.Struct({
+  id: AgentId,
+  name: Schema.String,
+  description: Schema.optional(Schema.String),
+  capabilities: Schema.Array(CapabilitySchema),
+  config: Schema.Unknown,
+  state: Schema.Unknown,
+  createdAt: Schema.DateFromSelf,
+  updatedAt: Schema.DateFromSelf
+});
+var AgentConfigSchema = Schema.Struct({
+  name: Schema.String,
+  description: Schema.optional(Schema.String),
+  capabilities: Schema.Array(CapabilitySchema),
+  config: Schema.optional(Schema.Unknown),
+  initialState: Schema.optional(Schema.Unknown)
+});
+
+// src/types/task.ts
+import { Schema as Schema2 } from "effect";
+var TaskId = Schema2.String.pipe(Schema2.brand("TaskId"));
+var TaskType = Schema2.Literal(
+  "query",
+  "action",
+  "workflow",
+  "research",
+  "delegation"
+);
+var Priority = Schema2.Literal("low", "medium", "high", "critical");
+var TaskStatus = Schema2.Literal(
+  "pending",
+  "running",
+  "paused",
+  "completed",
+  "failed",
+  "cancelled"
+);
+var TaskMetadataSchema = Schema2.Struct({
+  maxDuration: Schema2.optional(Schema2.Number),
+  maxCost: Schema2.optional(Schema2.Number),
+  requiresApproval: Schema2.optional(Schema2.Boolean),
+  tags: Schema2.optional(Schema2.Array(Schema2.String)),
+  context: Schema2.optional(
+    Schema2.Record({ key: Schema2.String, value: Schema2.Unknown })
+  )
+});
+var TaskSchema = Schema2.Struct({
+  id: TaskId,
+  agentId: AgentId,
+  type: TaskType,
+  input: Schema2.Unknown,
+  priority: Priority,
+  status: TaskStatus,
+  metadata: TaskMetadataSchema,
+  createdAt: Schema2.DateFromSelf,
+  startedAt: Schema2.optional(Schema2.DateFromSelf),
+  completedAt: Schema2.optional(Schema2.DateFromSelf)
+});
+var TaskConfigSchema = Schema2.Struct({
+  agentId: AgentId,
+  type: TaskType,
+  input: Schema2.Unknown,
+  priority: Schema2.optional(Priority),
+  metadata: Schema2.optional(TaskMetadataSchema)
+});
+
+// src/types/result.ts
+import { Schema as Schema3 } from "effect";
+var StepType = Schema3.Literal(
+  "thought",
+  "action",
+  "observation",
+  "plan",
+  "reflection",
+  "critique"
+);
+var ReasoningStepSchema = Schema3.Struct({
+  id: Schema3.String,
+  type: StepType,
+  content: Schema3.String,
+  timestamp: Schema3.DateFromSelf,
+  metadata: Schema3.optional(
+    Schema3.Struct({
+      confidence: Schema3.optional(Schema3.Number),
+      toolUsed: Schema3.optional(Schema3.String),
+      cost: Schema3.optional(Schema3.Number),
+      duration: Schema3.optional(Schema3.Number)
+    })
+  )
+});
+var ResultMetadataSchema = Schema3.Struct({
+  duration: Schema3.Number,
+  cost: Schema3.Number,
+  tokensUsed: Schema3.Number,
+  confidence: Schema3.optional(Schema3.Number.pipe(Schema3.between(0, 1))),
+  strategyUsed: Schema3.optional(Schema3.String),
+  stepsCount: Schema3.optional(Schema3.Number)
+});
+var TaskResultSchema = Schema3.Struct({
+  taskId: TaskId,
+  agentId: AgentId,
+  output: Schema3.Unknown,
+  success: Schema3.Boolean,
+  error: Schema3.optional(Schema3.String),
+  metadata: ResultMetadataSchema,
+  completedAt: Schema3.DateFromSelf
+});
+
+// src/types/message.ts
+import { Schema as Schema4 } from "effect";
+var MessageId = Schema4.String.pipe(Schema4.brand("MessageId"));
+var MessageType = Schema4.Literal(
+  "request",
+  "response",
+  "notification",
+  "delegation",
+  "query"
+);
+var MessageSchema = Schema4.Struct({
+  id: MessageId,
+  fromAgentId: AgentId,
+  toAgentId: AgentId,
+  type: MessageType,
+  content: Schema4.Unknown,
+  timestamp: Schema4.DateFromSelf,
+  metadata: Schema4.optional(
+    Schema4.Struct({
+      correlationId: Schema4.optional(Schema4.String),
+      causationId: Schema4.optional(Schema4.String),
+      context: Schema4.optional(
+        Schema4.Record({ key: Schema4.String, value: Schema4.Unknown })
+      )
+    })
+  )
+});
+
+// src/types/config.ts
+import { Schema as Schema5 } from "effect";
+var LogLevel = Schema5.Literal("debug", "info", "warn", "error");
+var TelemetryConfigSchema = Schema5.Struct({
+  enabled: Schema5.Boolean,
+  endpoint: Schema5.optional(Schema5.String),
+  serviceName: Schema5.String,
+  sampleRate: Schema5.Number.pipe(Schema5.between(0, 1))
+});
+var RuntimeConfigSchema = Schema5.Struct({
+  maxConcurrentTasks: Schema5.Number,
+  taskTimeout: Schema5.Number,
+  maxRetries: Schema5.Number,
+  retryDelay: Schema5.Number,
+  logLevel: LogLevel,
+  telemetry: TelemetryConfigSchema
+});
+var defaultRuntimeConfig = {
+  maxConcurrentTasks: 10,
+  taskTimeout: 3e5,
+  maxRetries: 3,
+  retryDelay: 1e3,
+  logLevel: "info",
+  telemetry: {
+    enabled: true,
+    serviceName: "reactive-agents",
+    sampleRate: 1
+  }
+};
+var ContextControllerSchema = Schema5.Struct({
+  prioritization: Schema5.optional(
+    Schema5.Literal("semantic", "recency", "importance")
+  ),
+  pruning: Schema5.optional(
+    Schema5.Literal("adaptive", "sliding-window", "fifo")
+  ),
+  retention: Schema5.optional(Schema5.Array(Schema5.String)),
+  compression: Schema5.optional(
+    Schema5.Literal("none", "aggressive", "adaptive")
+  )
+});
+var CircuitBreakerConfigSchema = Schema5.Struct({
+  errorThreshold: Schema5.Number.pipe(Schema5.between(0, 1)),
+  timeout: Schema5.Number,
+  // ms: max execution time before trip
+  resetTimeout: Schema5.Number
+  // ms: time before attempting reset
+});
+var TokenBudgetConfigSchema = Schema5.Struct({
+  total: Schema5.Number,
+  allocation: Schema5.optional(
+    Schema5.Struct({
+      system: Schema5.optional(Schema5.Number),
+      context: Schema5.optional(Schema5.Number),
+      reasoning: Schema5.optional(Schema5.Number),
+      output: Schema5.optional(Schema5.Number)
+    })
+  ),
+  enforcement: Schema5.Literal("hard", "soft")
+});
+var UncertaintySignalSchema = Schema5.Struct({
+  taskId: Schema5.String,
+  agentId: Schema5.String,
+  confidence: Schema5.Number,
+  phase: Schema5.String,
+  context: Schema5.String
+});
+var AgentDecisionSchema = Schema5.Struct({
+  type: Schema5.Literal("tool_call", "strategy_switch", "output"),
+  importance: Schema5.Number,
+  content: Schema5.Unknown
+});
+
+// src/services/agent-service.ts
+import { Effect as Effect2, Context as Context2, Layer as Layer2, Ref as Ref2 } from "effect";
+
+// src/id.ts
+import { ulid } from "ulid";
+var generateAgentId = () => ulid();
+var generateTaskId = () => ulid();
+var generateMessageId = () => ulid();
+
+// src/errors/errors.ts
+import { Data } from "effect";
+var AgentError = class extends Data.TaggedError("AgentError") {
+};
+var AgentNotFoundError = class extends Data.TaggedError("AgentNotFoundError") {
+};
+var TaskError = class extends Data.TaggedError("TaskError") {
+};
+var ValidationError = class extends Data.TaggedError("ValidationError") {
+};
+var RuntimeError = class extends Data.TaggedError("RuntimeError") {
+};
+
+// src/services/event-bus.ts
+import { Effect, Context, Layer, Ref } from "effect";
+var EventBus = class extends Context.Tag("EventBus")() {
+};
+var EventBusLive = Layer.effect(
+  EventBus,
+  Effect.gen(function* () {
+    const handlers = yield* Ref.make([]);
+    return {
+      publish: (event) => Effect.gen(function* () {
+        const hs = yield* Ref.get(handlers);
+        yield* Effect.all(
+          hs.map((h) => h(event)),
+          { concurrency: "unbounded" }
+        );
+      }),
+      subscribe: (handler) => Effect.gen(function* () {
+        yield* Ref.update(handlers, (hs) => [...hs, handler]);
+        return () => {
+          Effect.runSync(
+            Ref.update(handlers, (hs) => hs.filter((h) => h !== handler))
+          );
+        };
+      }),
+      on: (tag, handler) => Effect.gen(function* () {
+        const filtered = (event) => event._tag === tag ? handler(event) : Effect.void;
+        yield* Ref.update(handlers, (hs) => [...hs, filtered]);
+        return () => {
+          Effect.runSync(
+            Ref.update(handlers, (hs) => hs.filter((h) => h !== filtered))
+          );
+        };
+      })
+    };
+  })
+);
+
+// src/services/agent-service.ts
+var AgentService = class extends Context2.Tag("AgentService")() {
+};
+var AgentServiceLive = Layer2.effect(
+  AgentService,
+  Effect2.gen(function* () {
+    const eventBus = yield* EventBus;
+    const store = yield* Ref2.make(/* @__PURE__ */ new Map());
+    return {
+      create: (config) => Effect2.gen(function* () {
+        const now = /* @__PURE__ */ new Date();
+        const agent = {
+          id: generateAgentId(),
+          name: config.name,
+          description: config.description,
+          capabilities: config.capabilities ?? [],
+          config: config.config ?? {},
+          state: config.initialState ?? {},
+          createdAt: now,
+          updatedAt: now
+        };
+        yield* Ref2.update(store, (m) => new Map(m).set(agent.id, agent));
+        yield* eventBus.publish({ _tag: "AgentCreated", agentId: agent.id });
+        return agent;
+      }),
+      get: (id) => Effect2.gen(function* () {
+        const m = yield* Ref2.get(store);
+        const agent = m.get(id);
+        if (!agent) {
+          return yield* Effect2.fail(
+            new AgentNotFoundError({
+              agentId: id,
+              message: `Agent ${id} not found`
+            })
+          );
+        }
+        return agent;
+      }),
+      list: () => Effect2.gen(function* () {
+        const m = yield* Ref2.get(store);
+        return Array.from(m.values());
+      }),
+      delete: (id) => Effect2.gen(function* () {
+        const m = yield* Ref2.get(store);
+        if (!m.has(id)) {
+          return yield* Effect2.fail(
+            new AgentNotFoundError({
+              agentId: id,
+              message: `Agent ${id} not found`
+            })
+          );
+        }
+        yield* Ref2.update(store, (m2) => {
+          const next = new Map(m2);
+          next.delete(id);
+          return next;
+        });
+      })
+    };
+  })
+);
+
+// src/services/task-service.ts
+import { Effect as Effect3, Context as Context3, Layer as Layer3, Ref as Ref3 } from "effect";
+var TaskService = class extends Context3.Tag("TaskService")() {
+};
+var TaskServiceLive = Layer3.effect(
+  TaskService,
+  Effect3.gen(function* () {
+    const eventBus = yield* EventBus;
+    const store = yield* Ref3.make(/* @__PURE__ */ new Map());
+    return {
+      create: (config) => Effect3.gen(function* () {
+        const task = {
+          id: generateTaskId(),
+          agentId: config.agentId,
+          type: config.type,
+          input: config.input,
+          priority: config.priority ?? "medium",
+          status: "pending",
+          metadata: config.metadata ?? {},
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        yield* Ref3.update(store, (m) => new Map(m).set(task.id, task));
+        yield* eventBus.publish({ _tag: "TaskCreated", taskId: task.id });
+        return task;
+      }),
+      get: (id) => Effect3.gen(function* () {
+        const m = yield* Ref3.get(store);
+        const task = m.get(id);
+        if (!task) {
+          return yield* Effect3.fail(
+            new TaskError({ taskId: id, message: `Task ${id} not found` })
+          );
+        }
+        return task;
+      }),
+      updateStatus: (id, status) => Effect3.gen(function* () {
+        const m = yield* Ref3.get(store);
+        const task = m.get(id);
+        if (!task) {
+          return yield* Effect3.fail(
+            new TaskError({ taskId: id, message: `Task ${id} not found` })
+          );
+        }
+        const updated = { ...task, status };
+        yield* Ref3.update(store, (m2) => new Map(m2).set(id, updated));
+        if (status === "completed") {
+          yield* eventBus.publish({
+            _tag: "TaskCompleted",
+            taskId: id,
+            success: true
+          });
+        } else if (status === "failed") {
+          yield* eventBus.publish({
+            _tag: "TaskFailed",
+            taskId: id,
+            error: "Task failed"
+          });
+        }
+        return updated;
+      }),
+      cancel: (id) => Effect3.gen(function* () {
+        const m = yield* Ref3.get(store);
+        if (!m.has(id)) {
+          return yield* Effect3.fail(
+            new TaskError({ taskId: id, message: `Task ${id} not found` })
+          );
+        }
+        yield* Ref3.update(store, (m2) => {
+          const next = new Map(m2);
+          next.set(id, { ...next.get(id), status: "cancelled" });
+          return next;
+        });
+      })
+    };
+  })
+);
+
+// src/services/context-window-manager.ts
+import { Effect as Effect4, Context as Context4, Layer as Layer4, Data as Data2 } from "effect";
+var ContextError = class extends Data2.TaggedError("ContextError") {
+};
+var ContextWindowManager = class extends Context4.Tag("ContextWindowManager")() {
+};
+var estimateTokensImpl = (text) => Math.ceil(text.length / 4);
+var fitsInContextImpl = (messages, maxTokens) => {
+  const text = JSON.stringify(messages);
+  const estimated = estimateTokensImpl(text);
+  return estimated <= maxTokens;
+};
+var ContextWindowManagerLive = Layer4.succeed(ContextWindowManager, {
+  estimateTokens: (text) => Effect4.succeed(estimateTokensImpl(text)),
+  fitsInContext: (messages, maxTokens) => Effect4.succeed(fitsInContextImpl(messages, maxTokens)),
+  truncate: (messages, targetTokens, strategy) => Effect4.gen(function* () {
+    const arr = [...messages];
+    if (arr.length <= 1) return arr;
+    switch (strategy) {
+      case "drop-oldest": {
+        while (arr.length > 1) {
+          if (fitsInContextImpl(arr, targetTokens)) break;
+          arr.shift();
+        }
+        return arr;
+      }
+      case "drop-middle": {
+        while (arr.length > 2) {
+          if (fitsInContextImpl(arr, targetTokens)) break;
+          const mid = Math.floor(arr.length / 2);
+          arr.splice(mid, 1);
+        }
+        return arr;
+      }
+      default:
+        return yield* Effect4.fail(
+          new ContextError({
+            message: `Truncation strategy '${strategy}' not implemented in Phase 1`
+          })
+        );
+    }
+  }),
+  buildContext: (options) => Effect4.gen(function* () {
+    const budget = options.maxTokens - options.reserveOutputTokens;
+    const systemContent = options.memoryContext ? `${options.systemPrompt}
+
+## Agent Memory
+${options.memoryContext}` : options.systemPrompt;
+    const systemMsg = { role: "system", content: systemContent };
+    const systemTokens = estimateTokensImpl(systemContent);
+    const conversationBudget = budget - systemTokens;
+    const arr = [...options.messages];
+    while (arr.length > 1) {
+      if (fitsInContextImpl(arr, conversationBudget)) break;
+      arr.shift();
+    }
+    return [systemMsg, ...arr];
+  })
+});
+
+// src/runtime.ts
+import { Layer as Layer5 } from "effect";
+var CoreServicesLive = Layer5.mergeAll(
+  AgentServiceLive,
+  TaskServiceLive,
+  ContextWindowManagerLive
+).pipe(Layer5.provide(EventBusLive));
+export {
+  AgentConfigSchema,
+  AgentDecisionSchema,
+  AgentError,
+  AgentId,
+  AgentNotFoundError,
+  AgentSchema,
+  AgentService,
+  AgentServiceLive,
+  CapabilitySchema,
+  CapabilityType,
+  CircuitBreakerConfigSchema,
+  ContextControllerSchema,
+  ContextError,
+  ContextWindowManager,
+  ContextWindowManagerLive,
+  CoreServicesLive,
+  EventBus,
+  EventBusLive,
+  LogLevel,
+  MemoryType,
+  MessageId,
+  MessageSchema,
+  MessageType,
+  Priority,
+  ReasoningStepSchema,
+  ReasoningStrategy,
+  ResultMetadataSchema,
+  RuntimeConfigSchema,
+  RuntimeError,
+  StepType,
+  TaskConfigSchema,
+  TaskError,
+  TaskId,
+  TaskMetadataSchema,
+  TaskResultSchema,
+  TaskSchema,
+  TaskService,
+  TaskServiceLive,
+  TaskStatus,
+  TaskType,
+  TelemetryConfigSchema,
+  TokenBudgetConfigSchema,
+  UncertaintySignalSchema,
+  ValidationError,
+  defaultRuntimeConfig,
+  generateAgentId,
+  generateMessageId,
+  generateTaskId
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/agent.ts","../src/types/task.ts","../src/types/result.ts","../src/types/message.ts","../src/types/config.ts","../src/services/agent-service.ts","../src/id.ts","../src/errors/errors.ts","../src/services/event-bus.ts","../src/services/task-service.ts","../src/services/context-window-manager.ts","../src/runtime.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n// ─── Agent ID (branded string) ───\n\nexport const AgentId = Schema.String.pipe(Schema.brand(\"AgentId\"));\nexport type AgentId = typeof AgentId.Type;\n\n// ─── Capability ───\n\nexport const CapabilityType = Schema.Literal(\n  \"tool\",\n  \"skill\",\n  \"reasoning\",\n  \"memory\",\n);\nexport type CapabilityType = typeof CapabilityType.Type;\n\nexport const CapabilitySchema = Schema.Struct({\n  type: CapabilityType,\n  name: Schema.String,\n});\nexport type Capability = typeof CapabilitySchema.Type;\n\n// ─── Reasoning Strategy (shared across layers) ───\n\nexport const ReasoningStrategy = Schema.Literal(\n  \"reactive\",\n  \"plan-execute-reflect\",\n  \"tree-of-thought\",\n  \"reflexion\",\n  \"adaptive\",\n);\nexport type ReasoningStrategy = typeof ReasoningStrategy.Type;\n\n// ─── Memory Type ───\n// Updated: \"factual\" replaced by \"semantic\" + \"procedural\" (see 02-layer-memory.md)\n\nexport const MemoryType = Schema.Literal(\n  \"semantic\", // Long-term knowledge (SQLite + memory.md)\n  \"episodic\", // Daily logs + session snapshots\n  \"procedural\", // Learned workflows and patterns\n  \"working\", // In-process Ref, capacity 7\n);\nexport type MemoryType = typeof MemoryType.Type;\n\n// ─── Agent Schema ───\n\nexport const AgentSchema = Schema.Struct({\n  id: AgentId,\n  name: Schema.String,\n  description: Schema.optional(Schema.String),\n  capabilities: Schema.Array(CapabilitySchema),\n  config: Schema.Unknown,\n  state: Schema.Unknown,\n  createdAt: Schema.DateFromSelf,\n  updatedAt: Schema.DateFromSelf,\n});\nexport type Agent = typeof AgentSchema.Type;\n\n// ─── Agent Config (input for creating agents) ───\n\nexport const AgentConfigSchema = Schema.Struct({\n  name: Schema.String,\n  description: Schema.optional(Schema.String),\n  capabilities: Schema.Array(CapabilitySchema),\n  config: Schema.optional(Schema.Unknown),\n  initialState: Schema.optional(Schema.Unknown),\n});\nexport type AgentConfig = typeof AgentConfigSchema.Type;\n","import { Schema } from \"effect\";\nimport { AgentId } from \"./agent.js\";\n\n// ─── Task ID (branded string) ───\n\nexport const TaskId = Schema.String.pipe(Schema.brand(\"TaskId\"));\nexport type TaskId = typeof TaskId.Type;\n\n// ─── Task Type ───\n\nexport const TaskType = Schema.Literal(\n  \"query\",\n  \"action\",\n  \"workflow\",\n  \"research\",\n  \"delegation\",\n);\nexport type TaskType = typeof TaskType.Type;\n\n// ─── Priority ───\n\nexport const Priority = Schema.Literal(\"low\", \"medium\", \"high\", \"critical\");\nexport type Priority = typeof Priority.Type;\n\n// ─── Task Status ───\n\nexport const TaskStatus = Schema.Literal(\n  \"pending\",\n  \"running\",\n  \"paused\",\n  \"completed\",\n  \"failed\",\n  \"cancelled\",\n);\nexport type TaskStatus = typeof TaskStatus.Type;\n\n// ─── Task Metadata ───\n\nexport const TaskMetadataSchema = Schema.Struct({\n  maxDuration: Schema.optional(Schema.Number),\n  maxCost: Schema.optional(Schema.Number),\n  requiresApproval: Schema.optional(Schema.Boolean),\n  tags: Schema.optional(Schema.Array(Schema.String)),\n  context: Schema.optional(\n    Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n  ),\n});\nexport type TaskMetadata = typeof TaskMetadataSchema.Type;\n\n// ─── Task Schema ───\n\nexport const TaskSchema = Schema.Struct({\n  id: TaskId,\n  agentId: AgentId,\n  type: TaskType,\n  input: Schema.Unknown,\n  priority: Priority,\n  status: TaskStatus,\n  metadata: TaskMetadataSchema,\n  createdAt: Schema.DateFromSelf,\n  startedAt: Schema.optional(Schema.DateFromSelf),\n  completedAt: Schema.optional(Schema.DateFromSelf),\n});\nexport type Task = typeof TaskSchema.Type;\n\n// ─── Task Config (input for creating tasks) ───\n\nexport const TaskConfigSchema = Schema.Struct({\n  agentId: AgentId,\n  type: TaskType,\n  input: Schema.Unknown,\n  priority: Schema.optional(Priority),\n  metadata: Schema.optional(TaskMetadataSchema),\n});\nexport type TaskConfig = typeof TaskConfigSchema.Type;\n","import { Schema } from \"effect\";\nimport { AgentId } from \"./agent.js\";\nimport { TaskId } from \"./task.js\";\n\n// ─── Reasoning Step ───\n\nexport const StepType = Schema.Literal(\n  \"thought\",\n  \"action\",\n  \"observation\",\n  \"plan\",\n  \"reflection\",\n  \"critique\",\n);\nexport type StepType = typeof StepType.Type;\n\nexport const ReasoningStepSchema = Schema.Struct({\n  id: Schema.String,\n  type: StepType,\n  content: Schema.String,\n  timestamp: Schema.DateFromSelf,\n  metadata: Schema.optional(\n    Schema.Struct({\n      confidence: Schema.optional(Schema.Number),\n      toolUsed: Schema.optional(Schema.String),\n      cost: Schema.optional(Schema.Number),\n      duration: Schema.optional(Schema.Number),\n    }),\n  ),\n});\nexport type ReasoningStep = typeof ReasoningStepSchema.Type;\n\n// ─── Result Metadata ───\n\nexport const ResultMetadataSchema = Schema.Struct({\n  duration: Schema.Number,\n  cost: Schema.Number,\n  tokensUsed: Schema.Number,\n  confidence: Schema.optional(Schema.Number.pipe(Schema.between(0, 1))),\n  strategyUsed: Schema.optional(Schema.String),\n  stepsCount: Schema.optional(Schema.Number),\n});\nexport type ResultMetadata = typeof ResultMetadataSchema.Type;\n\n// ─── Task Result ───\n\nexport const TaskResultSchema = Schema.Struct({\n  taskId: TaskId,\n  agentId: AgentId,\n  output: Schema.Unknown,\n  success: Schema.Boolean,\n  error: Schema.optional(Schema.String),\n  metadata: ResultMetadataSchema,\n  completedAt: Schema.DateFromSelf,\n});\nexport type TaskResult = typeof TaskResultSchema.Type;\n","import { Schema } from \"effect\";\nimport { AgentId } from \"./agent.js\";\n\n// ─── Message ID (branded string) ───\n\nexport const MessageId = Schema.String.pipe(Schema.brand(\"MessageId\"));\nexport type MessageId = typeof MessageId.Type;\n\n// ─── Message Type ───\n\nexport const MessageType = Schema.Literal(\n  \"request\",\n  \"response\",\n  \"notification\",\n  \"delegation\",\n  \"query\",\n);\nexport type MessageType = typeof MessageType.Type;\n\n// ─── Message Schema ───\n\nexport const MessageSchema = Schema.Struct({\n  id: MessageId,\n  fromAgentId: AgentId,\n  toAgentId: AgentId,\n  type: MessageType,\n  content: Schema.Unknown,\n  timestamp: Schema.DateFromSelf,\n  metadata: Schema.optional(\n    Schema.Struct({\n      correlationId: Schema.optional(Schema.String),\n      causationId: Schema.optional(Schema.String),\n      context: Schema.optional(\n        Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n      ),\n    }),\n  ),\n});\nexport type Message = typeof MessageSchema.Type;\n","import { Schema } from \"effect\";\n\n// ─── Log Level ───\n\nexport const LogLevel = Schema.Literal(\"debug\", \"info\", \"warn\", \"error\");\nexport type LogLevel = typeof LogLevel.Type;\n\n// ─── Telemetry Config ───\n\nexport const TelemetryConfigSchema = Schema.Struct({\n  enabled: Schema.Boolean,\n  endpoint: Schema.optional(Schema.String),\n  serviceName: Schema.String,\n  sampleRate: Schema.Number.pipe(Schema.between(0, 1)),\n});\nexport type TelemetryConfig = typeof TelemetryConfigSchema.Type;\n\n// ─── Runtime Config ───\n\nexport const RuntimeConfigSchema = Schema.Struct({\n  maxConcurrentTasks: Schema.Number,\n  taskTimeout: Schema.Number,\n  maxRetries: Schema.Number,\n  retryDelay: Schema.Number,\n  logLevel: LogLevel,\n  telemetry: TelemetryConfigSchema,\n});\nexport type RuntimeConfig = typeof RuntimeConfigSchema.Type;\n\n// ─── Default Config ───\n\nexport const defaultRuntimeConfig: RuntimeConfig = {\n  maxConcurrentTasks: 10,\n  taskTimeout: 300_000,\n  maxRetries: 3,\n  retryDelay: 1_000,\n  logLevel: \"info\",\n  telemetry: {\n    enabled: true,\n    serviceName: \"reactive-agents\",\n    sampleRate: 1.0,\n  },\n};\n\n// ─── Context Controller (Vision Pillar: Control) ───\n\nexport const ContextControllerSchema = Schema.Struct({\n  prioritization: Schema.optional(\n    Schema.Literal(\"semantic\", \"recency\", \"importance\"),\n  ),\n  pruning: Schema.optional(\n    Schema.Literal(\"adaptive\", \"sliding-window\", \"fifo\"),\n  ),\n  retention: Schema.optional(Schema.Array(Schema.String)),\n  compression: Schema.optional(\n    Schema.Literal(\"none\", \"aggressive\", \"adaptive\"),\n  ),\n});\nexport type ContextController = typeof ContextControllerSchema.Type;\n\n// ─── Circuit Breaker (Vision Pillar: Reliability) ───\n\nexport const CircuitBreakerConfigSchema = Schema.Struct({\n  errorThreshold: Schema.Number.pipe(Schema.between(0, 1)),\n  timeout: Schema.Number, // ms: max execution time before trip\n  resetTimeout: Schema.Number, // ms: time before attempting reset\n});\nexport type CircuitBreakerConfig = typeof CircuitBreakerConfigSchema.Type;\n\n// ─── Token Budget (Vision Pillar: Efficiency) ───\n\nexport const TokenBudgetConfigSchema = Schema.Struct({\n  total: Schema.Number,\n  allocation: Schema.optional(\n    Schema.Struct({\n      system: Schema.optional(Schema.Number),\n      context: Schema.optional(Schema.Number),\n      reasoning: Schema.optional(Schema.Number),\n      output: Schema.optional(Schema.Number),\n    }),\n  ),\n  enforcement: Schema.Literal(\"hard\", \"soft\"),\n});\nexport type TokenBudgetConfig = typeof TokenBudgetConfigSchema.Type;\n\n// ─── Decision & Uncertainty Signals (Vision Pillar: Control) ───\n\nexport const UncertaintySignalSchema = Schema.Struct({\n  taskId: Schema.String,\n  agentId: Schema.String,\n  confidence: Schema.Number,\n  phase: Schema.String,\n  context: Schema.String,\n});\nexport type UncertaintySignal = typeof UncertaintySignalSchema.Type;\n\nexport const AgentDecisionSchema = Schema.Struct({\n  type: Schema.Literal(\"tool_call\", \"strategy_switch\", \"output\"),\n  importance: Schema.Number,\n  content: Schema.Unknown,\n});\nexport type AgentDecision = typeof AgentDecisionSchema.Type;\n","import { Effect, Context, Layer, Ref } from \"effect\";\nimport type { Agent, AgentConfig, AgentId } from \"../types/agent.js\";\nimport { generateAgentId } from \"../id.js\";\nimport { AgentError, AgentNotFoundError } from \"../errors/errors.js\";\nimport { EventBus } from \"./event-bus.js\";\n\n// ─── Service Tag ───\n\nexport class AgentService extends Context.Tag(\"AgentService\")<\n  AgentService,\n  {\n    /** Create a new agent from config. */\n    readonly create: (config: AgentConfig) => Effect.Effect<Agent, AgentError>;\n\n    /** Retrieve an agent by ID. */\n    readonly get: (id: AgentId) => Effect.Effect<Agent, AgentNotFoundError>;\n\n    /** List all registered agents. */\n    readonly list: () => Effect.Effect<readonly Agent[], never>;\n\n    /** Delete an agent by ID. */\n    readonly delete: (id: AgentId) => Effect.Effect<void, AgentNotFoundError>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const AgentServiceLive = Layer.effect(\n  AgentService,\n  Effect.gen(function* () {\n    const eventBus = yield* EventBus;\n    const store = yield* Ref.make<Map<string, Agent>>(new Map());\n\n    return {\n      create: (config: AgentConfig) =>\n        Effect.gen(function* () {\n          const now = new Date();\n          const agent: Agent = {\n            id: generateAgentId(),\n            name: config.name,\n            description: config.description,\n            capabilities: config.capabilities ?? [],\n            config: config.config ?? {},\n            state: config.initialState ?? {},\n            createdAt: now,\n            updatedAt: now,\n          };\n          yield* Ref.update(store, (m) => new Map(m).set(agent.id, agent));\n          yield* eventBus.publish({ _tag: \"AgentCreated\", agentId: agent.id });\n          return agent;\n        }),\n\n      get: (id: AgentId) =>\n        Effect.gen(function* () {\n          const m = yield* Ref.get(store);\n          const agent = m.get(id);\n          if (!agent) {\n            return yield* Effect.fail(\n              new AgentNotFoundError({\n                agentId: id,\n                message: `Agent ${id} not found`,\n              }),\n            );\n          }\n          return agent;\n        }),\n\n      list: () =>\n        Effect.gen(function* () {\n          const m = yield* Ref.get(store);\n          return Array.from(m.values());\n        }),\n\n      delete: (id: AgentId) =>\n        Effect.gen(function* () {\n          const m = yield* Ref.get(store);\n          if (!m.has(id)) {\n            return yield* Effect.fail(\n              new AgentNotFoundError({\n                agentId: id,\n                message: `Agent ${id} not found`,\n              }),\n            );\n          }\n          yield* Ref.update(store, (m) => {\n            const next = new Map(m);\n            next.delete(id);\n            return next;\n          });\n        }),\n    };\n  }),\n);\n","import { ulid } from \"ulid\";\nimport type { AgentId } from \"./types/agent.js\";\nimport type { TaskId } from \"./types/task.js\";\nimport type { MessageId } from \"./types/message.js\";\n\n/** Generate a new AgentId (ULID — sortable, globally unique). */\nexport const generateAgentId = (): AgentId => ulid() as AgentId;\n\n/** Generate a new TaskId. */\nexport const generateTaskId = (): TaskId => ulid() as TaskId;\n\n/** Generate a new MessageId. */\nexport const generateMessageId = (): MessageId => ulid() as MessageId;\n","import { Data } from \"effect\";\n\n/**\n * Base agent error — catch-all for unexpected agent failures.\n */\nexport class AgentError extends Data.TaggedError(\"AgentError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n/**\n * Agent not found in registry.\n */\nexport class AgentNotFoundError extends Data.TaggedError(\"AgentNotFoundError\")<{\n  readonly agentId: string;\n  readonly message: string;\n}> {}\n\n/**\n * Task execution failure.\n */\nexport class TaskError extends Data.TaggedError(\"TaskError\")<{\n  readonly taskId: string;\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n/**\n * Schema validation failure.\n */\nexport class ValidationError extends Data.TaggedError(\"ValidationError\")<{\n  readonly field: string;\n  readonly message: string;\n  readonly value?: unknown;\n}> {}\n\n/**\n * Runtime failure (fiber crash, timeout, etc.).\n */\nexport class RuntimeError extends Data.TaggedError(\"RuntimeError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n","import { Effect, Context, Layer, Ref } from \"effect\";\nimport type { Message } from \"../types/message.js\";\n\n// ─── Event Types ───\n\nexport type AgentEvent =\n  // ─── Core task/agent events ───\n  | { readonly _tag: \"TaskCreated\"; readonly taskId: string }\n  | {\n      readonly _tag: \"TaskCompleted\";\n      readonly taskId: string;\n      readonly success: boolean;\n    }\n  | {\n      readonly _tag: \"TaskFailed\";\n      readonly taskId: string;\n      readonly error: string;\n    }\n  | { readonly _tag: \"AgentCreated\"; readonly agentId: string }\n  | { readonly _tag: \"MessageSent\"; readonly message: Message }\n  // ─── Execution Engine events (from @reactive-agents/runtime) ───\n  | {\n      readonly _tag: \"ExecutionPhaseEntered\";\n      readonly taskId: string;\n      readonly phase: string;\n    }\n  | {\n      readonly _tag: \"ExecutionHookFired\";\n      readonly taskId: string;\n      readonly phase: string;\n      readonly timing: string;\n    }\n  | {\n      readonly _tag: \"ExecutionLoopIteration\";\n      readonly taskId: string;\n      readonly iteration: number;\n    }\n  | { readonly _tag: \"ExecutionCancelled\"; readonly taskId: string }\n  // ─── Memory events (from @reactive-agents/memory) ───\n  | {\n      readonly _tag: \"MemoryBootstrapped\";\n      readonly agentId: string;\n      readonly tier: string;\n    }\n  | { readonly _tag: \"MemoryFlushed\"; readonly agentId: string }\n  | {\n      readonly _tag: \"MemorySnapshotSaved\";\n      readonly agentId: string;\n      readonly sessionId: string;\n    }\n  // ─── Custom/extension events ───\n  | {\n      readonly _tag: \"Custom\";\n      readonly type: string;\n      readonly payload: unknown;\n    };\n\nexport type EventHandler = (event: AgentEvent) => Effect.Effect<void, never>;\n\n// ─── Service Tag ───\n\nexport class EventBus extends Context.Tag(\"EventBus\")<\n  EventBus,\n  {\n    /** Publish an event to all subscribers. */\n    readonly publish: (event: AgentEvent) => Effect.Effect<void, never>;\n\n    /** Subscribe a handler for all events. Returns unsubscribe function. */\n    readonly subscribe: (\n      handler: EventHandler,\n    ) => Effect.Effect<() => void, never>;\n\n    /** Subscribe only to events matching a tag. */\n    readonly on: (\n      tag: AgentEvent[\"_tag\"],\n      handler: EventHandler,\n    ) => Effect.Effect<() => void, never>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const EventBusLive = Layer.effect(\n  EventBus,\n  Effect.gen(function* () {\n    const handlers = yield* Ref.make<EventHandler[]>([]);\n\n    return {\n      publish: (event: AgentEvent) =>\n        Effect.gen(function* () {\n          const hs = yield* Ref.get(handlers);\n          yield* Effect.all(\n            hs.map((h) => h(event)),\n            { concurrency: \"unbounded\" },\n          );\n        }),\n\n      subscribe: (handler: EventHandler) =>\n        Effect.gen(function* () {\n          yield* Ref.update(handlers, (hs) => [...hs, handler]);\n          return () => {\n            Effect.runSync(\n              Ref.update(handlers, (hs) => hs.filter((h) => h !== handler)),\n            );\n          };\n        }),\n\n      on: (tag: AgentEvent[\"_tag\"], handler: EventHandler) =>\n        Effect.gen(function* () {\n          const filtered: EventHandler = (event) =>\n            event._tag === tag ? handler(event) : Effect.void;\n          yield* Ref.update(handlers, (hs) => [...hs, filtered]);\n          return () => {\n            Effect.runSync(\n              Ref.update(handlers, (hs) => hs.filter((h) => h !== filtered)),\n            );\n          };\n        }),\n    };\n  }),\n);\n","import { Effect, Context, Layer, Ref } from \"effect\";\nimport type { Task, TaskConfig, TaskId } from \"../types/task.js\";\nimport { generateTaskId } from \"../id.js\";\nimport { TaskError } from \"../errors/errors.js\";\nimport { EventBus } from \"./event-bus.js\";\n\n// ─── Service Tag ───\n\nexport class TaskService extends Context.Tag(\"TaskService\")<\n  TaskService,\n  {\n    /** Create a new task (status: pending). */\n    readonly create: (config: TaskConfig) => Effect.Effect<Task, TaskError>;\n\n    /** Get task by ID. */\n    readonly get: (id: TaskId) => Effect.Effect<Task, TaskError>;\n\n    /** Update task status. */\n    readonly updateStatus: (\n      id: TaskId,\n      status: Task[\"status\"],\n    ) => Effect.Effect<Task, TaskError>;\n\n    /** Cancel a running task. */\n    readonly cancel: (id: TaskId) => Effect.Effect<void, TaskError>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const TaskServiceLive = Layer.effect(\n  TaskService,\n  Effect.gen(function* () {\n    const eventBus = yield* EventBus;\n    const store = yield* Ref.make<Map<string, Task>>(new Map());\n\n    return {\n      create: (config: TaskConfig) =>\n        Effect.gen(function* () {\n          const task: Task = {\n            id: generateTaskId(),\n            agentId: config.agentId,\n            type: config.type,\n            input: config.input,\n            priority: config.priority ?? \"medium\",\n            status: \"pending\",\n            metadata: config.metadata ?? {},\n            createdAt: new Date(),\n          };\n          yield* Ref.update(store, (m) => new Map(m).set(task.id, task));\n          yield* eventBus.publish({ _tag: \"TaskCreated\", taskId: task.id });\n          return task;\n        }),\n\n      get: (id: TaskId) =>\n        Effect.gen(function* () {\n          const m = yield* Ref.get(store);\n          const task = m.get(id);\n          if (!task) {\n            return yield* Effect.fail(\n              new TaskError({ taskId: id, message: `Task ${id} not found` }),\n            );\n          }\n          return task;\n        }),\n\n      updateStatus: (id: TaskId, status: Task[\"status\"]) =>\n        Effect.gen(function* () {\n          const m = yield* Ref.get(store);\n          const task = m.get(id);\n          if (!task) {\n            return yield* Effect.fail(\n              new TaskError({ taskId: id, message: `Task ${id} not found` }),\n            );\n          }\n          const updated: Task = { ...task, status };\n          yield* Ref.update(store, (m) => new Map(m).set(id, updated));\n          if (status === \"completed\") {\n            yield* eventBus.publish({\n              _tag: \"TaskCompleted\",\n              taskId: id,\n              success: true,\n            });\n          } else if (status === \"failed\") {\n            yield* eventBus.publish({\n              _tag: \"TaskFailed\",\n              taskId: id,\n              error: \"Task failed\",\n            });\n          }\n          return updated;\n        }),\n\n      cancel: (id: TaskId) =>\n        Effect.gen(function* () {\n          const m = yield* Ref.get(store);\n          if (!m.has(id)) {\n            return yield* Effect.fail(\n              new TaskError({ taskId: id, message: `Task ${id} not found` }),\n            );\n          }\n          yield* Ref.update(store, (m) => {\n            const next = new Map(m);\n            next.set(id, { ...next.get(id)!, status: \"cancelled\" as const });\n            return next;\n          });\n        }),\n    };\n  }),\n);\n","import { Effect, Context, Layer, Data } from \"effect\";\n\n// ─── Truncation Strategy ───\n\nexport type TruncationStrategy =\n  | \"drop-oldest\" // Remove oldest messages first\n  | \"drop-middle\" // Keep first + last, drop middle\n  | \"summarize-oldest\"; // Summarize oldest messages (requires LLM — future Phase 2)\n\n// ─── Context Error ───\n\nexport class ContextError extends Data.TaggedError(\"ContextError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n// ─── Service Tag ───\n\nexport class ContextWindowManager extends Context.Tag(\"ContextWindowManager\")<\n  ContextWindowManager,\n  {\n    /**\n     * Build a context-window-safe message array.\n     * Injects memory context as a system message and truncates if needed.\n     */\n    readonly buildContext: (options: {\n      systemPrompt: string;\n      messages: readonly unknown[];\n      memoryContext?: string;\n      maxTokens: number;\n      reserveOutputTokens: number;\n    }) => Effect.Effect<readonly unknown[], ContextError>;\n\n    /**\n     * Estimate token count for a string.\n     * Uses character-based heuristic (1 token ~ 4 chars) when no tokenizer available.\n     */\n    readonly estimateTokens: (text: string) => Effect.Effect<number, never>;\n\n    /**\n     * Check if a message array fits within the context limit.\n     */\n    readonly fitsInContext: (\n      messages: readonly unknown[],\n      maxTokens: number,\n    ) => Effect.Effect<boolean, never>;\n\n    /**\n     * Truncate messages to fit within targetTokens.\n     */\n    readonly truncate: (\n      messages: readonly unknown[],\n      targetTokens: number,\n      strategy: TruncationStrategy,\n    ) => Effect.Effect<readonly unknown[], ContextError>;\n  }\n>() {}\n\n// ─── Helper functions (avoid self-referencing the service tag) ───\n\nconst estimateTokensImpl = (text: string): number =>\n  Math.ceil(text.length / 4);\n\nconst fitsInContextImpl = (\n  messages: readonly unknown[],\n  maxTokens: number,\n): boolean => {\n  const text = JSON.stringify(messages);\n  const estimated = estimateTokensImpl(text);\n  return estimated <= maxTokens;\n};\n\n// ─── Live Implementation ───\n\nexport const ContextWindowManagerLive = Layer.succeed(ContextWindowManager, {\n  estimateTokens: (text) => Effect.succeed(estimateTokensImpl(text)),\n\n  fitsInContext: (messages, maxTokens) =>\n    Effect.succeed(fitsInContextImpl(messages, maxTokens)),\n\n  truncate: (messages, targetTokens, strategy) =>\n    Effect.gen(function* () {\n      const arr = [...messages] as unknown[];\n\n      if (arr.length <= 1) return arr;\n\n      switch (strategy) {\n        case \"drop-oldest\": {\n          while (arr.length > 1) {\n            if (fitsInContextImpl(arr, targetTokens)) break;\n            arr.shift(); // Remove oldest\n          }\n          return arr;\n        }\n        case \"drop-middle\": {\n          while (arr.length > 2) {\n            if (fitsInContextImpl(arr, targetTokens)) break;\n            const mid = Math.floor(arr.length / 2);\n            arr.splice(mid, 1); // Remove middle message\n          }\n          return arr;\n        }\n        default:\n          return yield* Effect.fail(\n            new ContextError({\n              message: `Truncation strategy '${strategy}' not implemented in Phase 1`,\n            }),\n          );\n      }\n    }),\n\n  buildContext: (options) =>\n    Effect.gen(function* () {\n      const budget = options.maxTokens - options.reserveOutputTokens;\n\n      // Build system message with memory context injected\n      const systemContent = options.memoryContext\n        ? `${options.systemPrompt}\\n\\n## Agent Memory\\n${options.memoryContext}`\n        : options.systemPrompt;\n\n      const systemMsg = { role: \"system\", content: systemContent };\n      const systemTokens = estimateTokensImpl(systemContent);\n      const conversationBudget = budget - systemTokens;\n\n      // Truncate conversation to fit budget\n      const arr = [...options.messages] as unknown[];\n      while (arr.length > 1) {\n        if (fitsInContextImpl(arr, conversationBudget)) break;\n        arr.shift();\n      }\n\n      return [systemMsg, ...arr];\n    }),\n});\n","import { Layer } from \"effect\";\nimport { EventBusLive } from \"./services/event-bus.js\";\nimport { AgentServiceLive } from \"./services/agent-service.js\";\nimport { TaskServiceLive } from \"./services/task-service.js\";\nimport { ContextWindowManagerLive } from \"./services/context-window-manager.js\";\n\n/**\n * Complete core services layer.\n * Provides: EventBus, AgentService, TaskService, ContextWindowManager\n *\n * Usage:\n *   myProgram.pipe(Effect.provide(CoreServicesLive))\n */\nexport const CoreServicesLive = Layer.mergeAll(\n  AgentServiceLive,\n  TaskServiceLive,\n  ContextWindowManagerLive,\n).pipe(Layer.provide(EventBusLive));\n"],"mappings":";AAAA,SAAS,cAAc;AAIhB,IAAM,UAAU,OAAO,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAK1D,IAAM,iBAAiB,OAAO;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAGO,IAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,MAAM;AAAA,EACN,MAAM,OAAO;AACf,CAAC;AAKM,IAAM,oBAAoB,OAAO;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAMO,IAAM,aAAa,OAAO;AAAA,EAC/B;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACF;AAKO,IAAM,cAAc,OAAO,OAAO;AAAA,EACvC,IAAI;AAAA,EACJ,MAAM,OAAO;AAAA,EACb,aAAa,OAAO,SAAS,OAAO,MAAM;AAAA,EAC1C,cAAc,OAAO,MAAM,gBAAgB;AAAA,EAC3C,QAAQ,OAAO;AAAA,EACf,OAAO,OAAO;AAAA,EACd,WAAW,OAAO;AAAA,EAClB,WAAW,OAAO;AACpB,CAAC;AAKM,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,MAAM,OAAO;AAAA,EACb,aAAa,OAAO,SAAS,OAAO,MAAM;AAAA,EAC1C,cAAc,OAAO,MAAM,gBAAgB;AAAA,EAC3C,QAAQ,OAAO,SAAS,OAAO,OAAO;AAAA,EACtC,cAAc,OAAO,SAAS,OAAO,OAAO;AAC9C,CAAC;;;ACnED,SAAS,UAAAA,eAAc;AAKhB,IAAM,SAASC,QAAO,OAAO,KAAKA,QAAO,MAAM,QAAQ,CAAC;AAKxD,IAAM,WAAWA,QAAO;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAKO,IAAM,WAAWA,QAAO,QAAQ,OAAO,UAAU,QAAQ,UAAU;AAKnE,IAAM,aAAaA,QAAO;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAKO,IAAM,qBAAqBA,QAAO,OAAO;AAAA,EAC9C,aAAaA,QAAO,SAASA,QAAO,MAAM;AAAA,EAC1C,SAASA,QAAO,SAASA,QAAO,MAAM;AAAA,EACtC,kBAAkBA,QAAO,SAASA,QAAO,OAAO;AAAA,EAChD,MAAMA,QAAO,SAASA,QAAO,MAAMA,QAAO,MAAM,CAAC;AAAA,EACjD,SAASA,QAAO;AAAA,IACdA,QAAO,OAAO,EAAE,KAAKA,QAAO,QAAQ,OAAOA,QAAO,QAAQ,CAAC;AAAA,EAC7D;AACF,CAAC;AAKM,IAAM,aAAaA,QAAO,OAAO;AAAA,EACtC,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,MAAM;AAAA,EACN,OAAOA,QAAO;AAAA,EACd,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,WAAWA,QAAO;AAAA,EAClB,WAAWA,QAAO,SAASA,QAAO,YAAY;AAAA,EAC9C,aAAaA,QAAO,SAASA,QAAO,YAAY;AAClD,CAAC;AAKM,IAAM,mBAAmBA,QAAO,OAAO;AAAA,EAC5C,SAAS;AAAA,EACT,MAAM;AAAA,EACN,OAAOA,QAAO;AAAA,EACd,UAAUA,QAAO,SAAS,QAAQ;AAAA,EAClC,UAAUA,QAAO,SAAS,kBAAkB;AAC9C,CAAC;;;ACzED,SAAS,UAAAC,eAAc;AAMhB,IAAM,WAAWC,QAAO;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAGO,IAAM,sBAAsBA,QAAO,OAAO;AAAA,EAC/C,IAAIA,QAAO;AAAA,EACX,MAAM;AAAA,EACN,SAASA,QAAO;AAAA,EAChB,WAAWA,QAAO;AAAA,EAClB,UAAUA,QAAO;AAAA,IACfA,QAAO,OAAO;AAAA,MACZ,YAAYA,QAAO,SAASA,QAAO,MAAM;AAAA,MACzC,UAAUA,QAAO,SAASA,QAAO,MAAM;AAAA,MACvC,MAAMA,QAAO,SAASA,QAAO,MAAM;AAAA,MACnC,UAAUA,QAAO,SAASA,QAAO,MAAM;AAAA,IACzC,CAAC;AAAA,EACH;AACF,CAAC;AAKM,IAAM,uBAAuBA,QAAO,OAAO;AAAA,EAChD,UAAUA,QAAO;AAAA,EACjB,MAAMA,QAAO;AAAA,EACb,YAAYA,QAAO;AAAA,EACnB,YAAYA,QAAO,SAASA,QAAO,OAAO,KAAKA,QAAO,QAAQ,GAAG,CAAC,CAAC,CAAC;AAAA,EACpE,cAAcA,QAAO,SAASA,QAAO,MAAM;AAAA,EAC3C,YAAYA,QAAO,SAASA,QAAO,MAAM;AAC3C,CAAC;AAKM,IAAM,mBAAmBA,QAAO,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQA,QAAO;AAAA,EACf,SAASA,QAAO;AAAA,EAChB,OAAOA,QAAO,SAASA,QAAO,MAAM;AAAA,EACpC,UAAU;AAAA,EACV,aAAaA,QAAO;AACtB,CAAC;;;ACtDD,SAAS,UAAAC,eAAc;AAKhB,IAAM,YAAYC,QAAO,OAAO,KAAKA,QAAO,MAAM,WAAW,CAAC;AAK9D,IAAM,cAAcA,QAAO;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAKO,IAAM,gBAAgBA,QAAO,OAAO;AAAA,EACzC,IAAI;AAAA,EACJ,aAAa;AAAA,EACb,WAAW;AAAA,EACX,MAAM;AAAA,EACN,SAASA,QAAO;AAAA,EAChB,WAAWA,QAAO;AAAA,EAClB,UAAUA,QAAO;AAAA,IACfA,QAAO,OAAO;AAAA,MACZ,eAAeA,QAAO,SAASA,QAAO,MAAM;AAAA,MAC5C,aAAaA,QAAO,SAASA,QAAO,MAAM;AAAA,MAC1C,SAASA,QAAO;AAAA,QACdA,QAAO,OAAO,EAAE,KAAKA,QAAO,QAAQ,OAAOA,QAAO,QAAQ,CAAC;AAAA,MAC7D;AAAA,IACF,CAAC;AAAA,EACH;AACF,CAAC;;;ACrCD,SAAS,UAAAC,eAAc;AAIhB,IAAM,WAAWA,QAAO,QAAQ,SAAS,QAAQ,QAAQ,OAAO;AAKhE,IAAM,wBAAwBA,QAAO,OAAO;AAAA,EACjD,SAASA,QAAO;AAAA,EAChB,UAAUA,QAAO,SAASA,QAAO,MAAM;AAAA,EACvC,aAAaA,QAAO;AAAA,EACpB,YAAYA,QAAO,OAAO,KAAKA,QAAO,QAAQ,GAAG,CAAC,CAAC;AACrD,CAAC;AAKM,IAAM,sBAAsBA,QAAO,OAAO;AAAA,EAC/C,oBAAoBA,QAAO;AAAA,EAC3B,aAAaA,QAAO;AAAA,EACpB,YAAYA,QAAO;AAAA,EACnB,YAAYA,QAAO;AAAA,EACnB,UAAU;AAAA,EACV,WAAW;AACb,CAAC;AAKM,IAAM,uBAAsC;AAAA,EACjD,oBAAoB;AAAA,EACpB,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,WAAW;AAAA,IACT,SAAS;AAAA,IACT,aAAa;AAAA,IACb,YAAY;AAAA,EACd;AACF;AAIO,IAAM,0BAA0BA,QAAO,OAAO;AAAA,EACnD,gBAAgBA,QAAO;AAAA,IACrBA,QAAO,QAAQ,YAAY,WAAW,YAAY;AAAA,EACpD;AAAA,EACA,SAASA,QAAO;AAAA,IACdA,QAAO,QAAQ,YAAY,kBAAkB,MAAM;AAAA,EACrD;AAAA,EACA,WAAWA,QAAO,SAASA,QAAO,MAAMA,QAAO,MAAM,CAAC;AAAA,EACtD,aAAaA,QAAO;AAAA,IAClBA,QAAO,QAAQ,QAAQ,cAAc,UAAU;AAAA,EACjD;AACF,CAAC;AAKM,IAAM,6BAA6BA,QAAO,OAAO;AAAA,EACtD,gBAAgBA,QAAO,OAAO,KAAKA,QAAO,QAAQ,GAAG,CAAC,CAAC;AAAA,EACvD,SAASA,QAAO;AAAA;AAAA,EAChB,cAAcA,QAAO;AAAA;AACvB,CAAC;AAKM,IAAM,0BAA0BA,QAAO,OAAO;AAAA,EACnD,OAAOA,QAAO;AAAA,EACd,YAAYA,QAAO;AAAA,IACjBA,QAAO,OAAO;AAAA,MACZ,QAAQA,QAAO,SAASA,QAAO,MAAM;AAAA,MACrC,SAASA,QAAO,SAASA,QAAO,MAAM;AAAA,MACtC,WAAWA,QAAO,SAASA,QAAO,MAAM;AAAA,MACxC,QAAQA,QAAO,SAASA,QAAO,MAAM;AAAA,IACvC,CAAC;AAAA,EACH;AAAA,EACA,aAAaA,QAAO,QAAQ,QAAQ,MAAM;AAC5C,CAAC;AAKM,IAAM,0BAA0BA,QAAO,OAAO;AAAA,EACnD,QAAQA,QAAO;AAAA,EACf,SAASA,QAAO;AAAA,EAChB,YAAYA,QAAO;AAAA,EACnB,OAAOA,QAAO;AAAA,EACd,SAASA,QAAO;AAClB,CAAC;AAGM,IAAM,sBAAsBA,QAAO,OAAO;AAAA,EAC/C,MAAMA,QAAO,QAAQ,aAAa,mBAAmB,QAAQ;AAAA,EAC7D,YAAYA,QAAO;AAAA,EACnB,SAASA,QAAO;AAClB,CAAC;;;ACpGD,SAAS,UAAAC,SAAQ,WAAAC,UAAS,SAAAC,QAAO,OAAAC,YAAW;;;ACA5C,SAAS,YAAY;AAMd,IAAM,kBAAkB,MAAe,KAAK;AAG5C,IAAM,iBAAiB,MAAc,KAAK;AAG1C,IAAM,oBAAoB,MAAiB,KAAK;;;ACZvD,SAAS,YAAY;AAKd,IAAM,aAAN,cAAyB,KAAK,YAAY,YAAY,EAG1D;AAAC;AAKG,IAAM,qBAAN,cAAiC,KAAK,YAAY,oBAAoB,EAG1E;AAAC;AAKG,IAAM,YAAN,cAAwB,KAAK,YAAY,WAAW,EAIxD;AAAC;AAKG,IAAM,kBAAN,cAA8B,KAAK,YAAY,iBAAiB,EAIpE;AAAC;AAKG,IAAM,eAAN,cAA2B,KAAK,YAAY,cAAc,EAG9D;AAAC;;;AC1CJ,SAAS,QAAQ,SAAS,OAAO,WAAW;AA6DrC,IAAM,WAAN,cAAuB,QAAQ,IAAI,UAAU,EAiBlD,EAAE;AAAC;AAIE,IAAM,eAAe,MAAM;AAAA,EAChC;AAAA,EACA,OAAO,IAAI,aAAa;AACtB,UAAM,WAAW,OAAO,IAAI,KAAqB,CAAC,CAAC;AAEnD,WAAO;AAAA,MACL,SAAS,CAAC,UACR,OAAO,IAAI,aAAa;AACtB,cAAM,KAAK,OAAO,IAAI,IAAI,QAAQ;AAClC,eAAO,OAAO;AAAA,UACZ,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC;AAAA,UACtB,EAAE,aAAa,YAAY;AAAA,QAC7B;AAAA,MACF,CAAC;AAAA,MAEH,WAAW,CAAC,YACV,OAAO,IAAI,aAAa;AACtB,eAAO,IAAI,OAAO,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC;AACpD,eAAO,MAAM;AACX,iBAAO;AAAA,YACL,IAAI,OAAO,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,MAAM,OAAO,CAAC;AAAA,UAC9D;AAAA,QACF;AAAA,MACF,CAAC;AAAA,MAEH,IAAI,CAAC,KAAyB,YAC5B,OAAO,IAAI,aAAa;AACtB,cAAM,WAAyB,CAAC,UAC9B,MAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,OAAO;AAC/C,eAAO,IAAI,OAAO,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,QAAQ,CAAC;AACrD,eAAO,MAAM;AACX,iBAAO;AAAA,YACL,IAAI,OAAO,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,MAAM,QAAQ,CAAC;AAAA,UAC/D;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACL;AAAA,EACF,CAAC;AACH;;;AHhHO,IAAM,eAAN,cAA2BC,SAAQ,IAAI,cAAc,EAe1D,EAAE;AAAC;AAIE,IAAM,mBAAmBC,OAAM;AAAA,EACpC;AAAA,EACAC,QAAO,IAAI,aAAa;AACtB,UAAM,WAAW,OAAO;AACxB,UAAM,QAAQ,OAAOC,KAAI,KAAyB,oBAAI,IAAI,CAAC;AAE3D,WAAO;AAAA,MACL,QAAQ,CAAC,WACPD,QAAO,IAAI,aAAa;AACtB,cAAM,MAAM,oBAAI,KAAK;AACrB,cAAM,QAAe;AAAA,UACnB,IAAI,gBAAgB;AAAA,UACpB,MAAM,OAAO;AAAA,UACb,aAAa,OAAO;AAAA,UACpB,cAAc,OAAO,gBAAgB,CAAC;AAAA,UACtC,QAAQ,OAAO,UAAU,CAAC;AAAA,UAC1B,OAAO,OAAO,gBAAgB,CAAC;AAAA,UAC/B,WAAW;AAAA,UACX,WAAW;AAAA,QACb;AACA,eAAOC,KAAI,OAAO,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,EAAE,IAAI,MAAM,IAAI,KAAK,CAAC;AAC/D,eAAO,SAAS,QAAQ,EAAE,MAAM,gBAAgB,SAAS,MAAM,GAAG,CAAC;AACnE,eAAO;AAAA,MACT,CAAC;AAAA,MAEH,KAAK,CAAC,OACJD,QAAO,IAAI,aAAa;AACtB,cAAM,IAAI,OAAOC,KAAI,IAAI,KAAK;AAC9B,cAAM,QAAQ,EAAE,IAAI,EAAE;AACtB,YAAI,CAAC,OAAO;AACV,iBAAO,OAAOD,QAAO;AAAA,YACnB,IAAI,mBAAmB;AAAA,cACrB,SAAS;AAAA,cACT,SAAS,SAAS,EAAE;AAAA,YACtB,CAAC;AAAA,UACH;AAAA,QACF;AACA,eAAO;AAAA,MACT,CAAC;AAAA,MAEH,MAAM,MACJA,QAAO,IAAI,aAAa;AACtB,cAAM,IAAI,OAAOC,KAAI,IAAI,KAAK;AAC9B,eAAO,MAAM,KAAK,EAAE,OAAO,CAAC;AAAA,MAC9B,CAAC;AAAA,MAEH,QAAQ,CAAC,OACPD,QAAO,IAAI,aAAa;AACtB,cAAM,IAAI,OAAOC,KAAI,IAAI,KAAK;AAC9B,YAAI,CAAC,EAAE,IAAI,EAAE,GAAG;AACd,iBAAO,OAAOD,QAAO;AAAA,YACnB,IAAI,mBAAmB;AAAA,cACrB,SAAS;AAAA,cACT,SAAS,SAAS,EAAE;AAAA,YACtB,CAAC;AAAA,UACH;AAAA,QACF;AACA,eAAOC,KAAI,OAAO,OAAO,CAACC,OAAM;AAC9B,gBAAM,OAAO,IAAI,IAAIA,EAAC;AACtB,eAAK,OAAO,EAAE;AACd,iBAAO;AAAA,QACT,CAAC;AAAA,MACH,CAAC;AAAA,IACL;AAAA,EACF,CAAC;AACH;;;AI5FA,SAAS,UAAAC,SAAQ,WAAAC,UAAS,SAAAC,QAAO,OAAAC,YAAW;AAQrC,IAAM,cAAN,cAA0BC,SAAQ,IAAI,aAAa,EAkBxD,EAAE;AAAC;AAIE,IAAM,kBAAkBC,OAAM;AAAA,EACnC;AAAA,EACAC,QAAO,IAAI,aAAa;AACtB,UAAM,WAAW,OAAO;AACxB,UAAM,QAAQ,OAAOC,KAAI,KAAwB,oBAAI,IAAI,CAAC;AAE1D,WAAO;AAAA,MACL,QAAQ,CAAC,WACPD,QAAO,IAAI,aAAa;AACtB,cAAM,OAAa;AAAA,UACjB,IAAI,eAAe;AAAA,UACnB,SAAS,OAAO;AAAA,UAChB,MAAM,OAAO;AAAA,UACb,OAAO,OAAO;AAAA,UACd,UAAU,OAAO,YAAY;AAAA,UAC7B,QAAQ;AAAA,UACR,UAAU,OAAO,YAAY,CAAC;AAAA,UAC9B,WAAW,oBAAI,KAAK;AAAA,QACtB;AACA,eAAOC,KAAI,OAAO,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC;AAC7D,eAAO,SAAS,QAAQ,EAAE,MAAM,eAAe,QAAQ,KAAK,GAAG,CAAC;AAChE,eAAO;AAAA,MACT,CAAC;AAAA,MAEH,KAAK,CAAC,OACJD,QAAO,IAAI,aAAa;AACtB,cAAM,IAAI,OAAOC,KAAI,IAAI,KAAK;AAC9B,cAAM,OAAO,EAAE,IAAI,EAAE;AACrB,YAAI,CAAC,MAAM;AACT,iBAAO,OAAOD,QAAO;AAAA,YACnB,IAAI,UAAU,EAAE,QAAQ,IAAI,SAAS,QAAQ,EAAE,aAAa,CAAC;AAAA,UAC/D;AAAA,QACF;AACA,eAAO;AAAA,MACT,CAAC;AAAA,MAEH,cAAc,CAAC,IAAY,WACzBA,QAAO,IAAI,aAAa;AACtB,cAAM,IAAI,OAAOC,KAAI,IAAI,KAAK;AAC9B,cAAM,OAAO,EAAE,IAAI,EAAE;AACrB,YAAI,CAAC,MAAM;AACT,iBAAO,OAAOD,QAAO;AAAA,YACnB,IAAI,UAAU,EAAE,QAAQ,IAAI,SAAS,QAAQ,EAAE,aAAa,CAAC;AAAA,UAC/D;AAAA,QACF;AACA,cAAM,UAAgB,EAAE,GAAG,MAAM,OAAO;AACxC,eAAOC,KAAI,OAAO,OAAO,CAACC,OAAM,IAAI,IAAIA,EAAC,EAAE,IAAI,IAAI,OAAO,CAAC;AAC3D,YAAI,WAAW,aAAa;AAC1B,iBAAO,SAAS,QAAQ;AAAA,YACtB,MAAM;AAAA,YACN,QAAQ;AAAA,YACR,SAAS;AAAA,UACX,CAAC;AAAA,QACH,WAAW,WAAW,UAAU;AAC9B,iBAAO,SAAS,QAAQ;AAAA,YACtB,MAAM;AAAA,YACN,QAAQ;AAAA,YACR,OAAO;AAAA,UACT,CAAC;AAAA,QACH;AACA,eAAO;AAAA,MACT,CAAC;AAAA,MAEH,QAAQ,CAAC,OACPF,QAAO,IAAI,aAAa;AACtB,cAAM,IAAI,OAAOC,KAAI,IAAI,KAAK;AAC9B,YAAI,CAAC,EAAE,IAAI,EAAE,GAAG;AACd,iBAAO,OAAOD,QAAO;AAAA,YACnB,IAAI,UAAU,EAAE,QAAQ,IAAI,SAAS,QAAQ,EAAE,aAAa,CAAC;AAAA,UAC/D;AAAA,QACF;AACA,eAAOC,KAAI,OAAO,OAAO,CAACC,OAAM;AAC9B,gBAAM,OAAO,IAAI,IAAIA,EAAC;AACtB,eAAK,IAAI,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,GAAI,QAAQ,YAAqB,CAAC;AAC/D,iBAAO;AAAA,QACT,CAAC;AAAA,MACH,CAAC;AAAA,IACL;AAAA,EACF,CAAC;AACH;;;AC7GA,SAAS,UAAAC,SAAQ,WAAAC,UAAS,SAAAC,QAAO,QAAAC,aAAY;AAWtC,IAAM,eAAN,cAA2BA,MAAK,YAAY,cAAc,EAG9D;AAAC;AAIG,IAAM,uBAAN,cAAmCF,SAAQ,IAAI,sBAAsB,EAsC1E,EAAE;AAAC;AAIL,IAAM,qBAAqB,CAAC,SAC1B,KAAK,KAAK,KAAK,SAAS,CAAC;AAE3B,IAAM,oBAAoB,CACxB,UACA,cACY;AACZ,QAAM,OAAO,KAAK,UAAU,QAAQ;AACpC,QAAM,YAAY,mBAAmB,IAAI;AACzC,SAAO,aAAa;AACtB;AAIO,IAAM,2BAA2BC,OAAM,QAAQ,sBAAsB;AAAA,EAC1E,gBAAgB,CAAC,SAASF,QAAO,QAAQ,mBAAmB,IAAI,CAAC;AAAA,EAEjE,eAAe,CAAC,UAAU,cACxBA,QAAO,QAAQ,kBAAkB,UAAU,SAAS,CAAC;AAAA,EAEvD,UAAU,CAAC,UAAU,cAAc,aACjCA,QAAO,IAAI,aAAa;AACtB,UAAM,MAAM,CAAC,GAAG,QAAQ;AAExB,QAAI,IAAI,UAAU,EAAG,QAAO;AAE5B,YAAQ,UAAU;AAAA,MAChB,KAAK,eAAe;AAClB,eAAO,IAAI,SAAS,GAAG;AACrB,cAAI,kBAAkB,KAAK,YAAY,EAAG;AAC1C,cAAI,MAAM;AAAA,QACZ;AACA,eAAO;AAAA,MACT;AAAA,MACA,KAAK,eAAe;AAClB,eAAO,IAAI,SAAS,GAAG;AACrB,cAAI,kBAAkB,KAAK,YAAY,EAAG;AAC1C,gBAAM,MAAM,KAAK,MAAM,IAAI,SAAS,CAAC;AACrC,cAAI,OAAO,KAAK,CAAC;AAAA,QACnB;AACA,eAAO;AAAA,MACT;AAAA,MACA;AACE,eAAO,OAAOA,QAAO;AAAA,UACnB,IAAI,aAAa;AAAA,YACf,SAAS,wBAAwB,QAAQ;AAAA,UAC3C,CAAC;AAAA,QACH;AAAA,IACJ;AAAA,EACF,CAAC;AAAA,EAEH,cAAc,CAAC,YACbA,QAAO,IAAI,aAAa;AACtB,UAAM,SAAS,QAAQ,YAAY,QAAQ;AAG3C,UAAM,gBAAgB,QAAQ,gBAC1B,GAAG,QAAQ,YAAY;AAAA;AAAA;AAAA,EAAwB,QAAQ,aAAa,KACpE,QAAQ;AAEZ,UAAM,YAAY,EAAE,MAAM,UAAU,SAAS,cAAc;AAC3D,UAAM,eAAe,mBAAmB,aAAa;AACrD,UAAM,qBAAqB,SAAS;AAGpC,UAAM,MAAM,CAAC,GAAG,QAAQ,QAAQ;AAChC,WAAO,IAAI,SAAS,GAAG;AACrB,UAAI,kBAAkB,KAAK,kBAAkB,EAAG;AAChD,UAAI,MAAM;AAAA,IACZ;AAEA,WAAO,CAAC,WAAW,GAAG,GAAG;AAAA,EAC3B,CAAC;AACL,CAAC;;;ACrID,SAAS,SAAAI,cAAa;AAaf,IAAM,mBAAmBC,OAAM;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAKA,OAAM,QAAQ,YAAY,CAAC;","names":["Schema","Schema","Schema","Schema","Schema","Schema","Schema","Effect","Context","Layer","Ref","Context","Layer","Effect","Ref","m","Effect","Context","Layer","Ref","Context","Layer","Effect","Ref","m","Effect","Context","Layer","Data","Layer","Layer"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@reactive-agents/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.base.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "dependencies": {
+    "effect": "^3.10.0",
+    "ulid": "^2.3.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "bun-types": "latest"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Core services for Reactive Agents — EventBus, AgentService, TaskService, and shared types",
+  "homepage": "https://tylerjrbuell.github.io/reactive-agents-ts/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}