@almadar/agent 2.0.0 → 2.0.1

package/dist/tools/orbital-batch-subagent.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Orbital Batch Subagent Tool
+ *
+ * Tool for generating multiple orbitals in optimized batches.
+ * Provides significant speedup (2x-3x) for multi-orbital generation.
+ *
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+import type { OrbitalDefinition } from '@almadar/core/types';
+import { type LLMProvider } from '@almadar/llm';
+import type { SSEEventType } from '../api-types.js';
+import { type ExtractedRequirements } from '../orbitals/shared/index.js';
+export type SubagentEventCallback = (orbitalName: string, orbitalIndex: number, totalOrbitals: number, event: {
+    type: Exclude<SSEEventType, 'subagent_event'>;
+    data: Record<string, unknown>;
+    timestamp: number;
+}) => void;
+export type BatchCompleteCallback = (orbitals: OrbitalDefinition[], batchIndex: number, totalBatches: number) => Promise<void> | void;
+export interface OrbitalBatchSubagentToolOptions {
+    onSubagentEvent?: SubagentEventCallback;
+    onBatchComplete?: BatchCompleteCallback;
+    requirements?: Partial<ExtractedRequirements>;
+    provider?: LLMProvider;
+    model?: string;
+    workDir?: string;
+}
+/**
+ * Create a tool for batch orbital generation with event streaming.
+ */
+export declare function createOrbitalBatchSubagentTool(options?: OrbitalBatchSubagentToolOptions): {
+    tool: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+        orbitals: z.ZodArray<z.ZodAny, "many">;
+        options: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["single-call", "parallel-individual", "adaptive"]>>>;
+            batchSize: z.ZodOptional<z.ZodNumber>;
+            maxConcurrency: z.ZodOptional<z.ZodNumber>;
+            preserveRelationships: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "single-call" | "parallel-individual" | "adaptive";
+            preserveRelationships: boolean;
+            batchSize?: number | undefined;
+            maxConcurrency?: number | undefined;
+        }, {
+            batchSize?: number | undefined;
+            mode?: "single-call" | "parallel-individual" | "adaptive" | undefined;
+            preserveRelationships?: boolean | undefined;
+            maxConcurrency?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        orbitals: any[];
+        options?: {
+            mode: "single-call" | "parallel-individual" | "adaptive";
+            preserveRelationships: boolean;
+            batchSize?: number | undefined;
+            maxConcurrency?: number | undefined;
+        } | undefined;
+    }, {
+        orbitals: any[];
+        options?: {
+            batchSize?: number | undefined;
+            mode?: "single-call" | "parallel-individual" | "adaptive" | undefined;
+            preserveRelationships?: boolean | undefined;
+            maxConcurrency?: number | undefined;
+        } | undefined;
+    }>, {
+        orbitals: any[];
+        options?: {
+            mode: "single-call" | "parallel-individual" | "adaptive";
+            preserveRelationships: boolean;
+            batchSize?: number | undefined;
+            maxConcurrency?: number | undefined;
+        } | undefined;
+    }, {
+        orbitals: any[];
+        options?: {
+            batchSize?: number | undefined;
+            mode?: "single-call" | "parallel-individual" | "adaptive" | undefined;
+            preserveRelationships?: boolean | undefined;
+            maxConcurrency?: number | undefined;
+        } | undefined;
+    }, string, "generate_orbitals_batch">;
+    setEventCallback: (callback: SubagentEventCallback) => void;
+    setBatchCompleteCallback: (callback: BatchCompleteCallback) => void;
+};

package/dist/tools/orbital-subagent.d.ts

@@ -0,0 +1,454 @@
+/**
+ * Orbital Subagent Tool
+ *
+ * Spawns nested DeepAgents for orbital generation and forwards
+ * their events to the parent stream.
+ * Uses @almadar/llm LLMClient directly.
+ *
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+import { type LLMProvider } from '@almadar/llm';
+import type { SSEEvent, SSEEventType } from '../api-types.js';
+export type SubagentEventCallback = (orbitalName: string, orbitalIndex: number, totalOrbitals: number, event: {
+    type: Exclude<SSEEventType, 'subagent_event'>;
+    data: Record<string, unknown>;
+    timestamp: number;
+}) => void;
+export type OrbitalCompleteCallback = (orbital: unknown, orbitalName: string, orbitalIndex: number, totalOrbitals: number) => void | Promise<void>;
+export interface OrbitalRequirements {
+    entities?: string[];
+    states?: string[];
+    events?: string[];
+    guards?: string[];
+    pages?: string[];
+    effects?: string[];
+    rawRequirements?: string[];
+}
+export interface OrbitalSubagentToolOptions {
+    onSubagentEvent?: SubagentEventCallback;
+    onOrbitalComplete?: OrbitalCompleteCallback;
+    requirements?: OrbitalRequirements;
+    /** LLM provider for orbital generation subagent. Defaults to 'anthropic' */
+    provider?: LLMProvider;
+    /** Model name for orbital generation subagent. Defaults to 'claude-sonnet-4-20250514' */
+    model?: string;
+    /** Working directory for persisting orbital files. When set, orbitals are written to .orbitals/ */
+    workDir?: string;
+}
+/**
+ * Create a tool for generating orbitals with subagent event streaming.
+ * Uses @almadar/llm LLMClient directly.
+ */
+export declare function createOrbitalSubagentTool(options?: OrbitalSubagentToolOptions): {
+    tool: import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+        orbital: z.ZodObject<{
+            name: z.ZodString;
+            entity: z.ZodObject<{
+                name: z.ZodString;
+                persistence: z.ZodEnum<["persistent", "runtime", "singleton", "instance"]>;
+                fields: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }, {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            }, {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            }>;
+            traits: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                path: z.ZodString;
+                viewType: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                name: string;
+                viewType: string;
+            }, {
+                path: string;
+                name: string;
+                viewType: string;
+            }>, "many">>;
+            domainContext: z.ZodOptional<z.ZodObject<{
+                request: z.ZodString;
+                requestFragment: z.ZodOptional<z.ZodString>;
+                category: z.ZodEnum<["game", "business", "dashboard", "form", "content", "social", "ecommerce", "workflow"]>;
+                vocabulary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            }, {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            }>>;
+            design: z.ZodOptional<z.ZodObject<{
+                style: z.ZodOptional<z.ZodEnum<["minimal", "modern", "playful", "data-driven", "immersive"]>>;
+                uxHints: z.ZodOptional<z.ZodObject<{
+                    flowPattern: z.ZodOptional<z.ZodString>;
+                    listPattern: z.ZodOptional<z.ZodString>;
+                    formPattern: z.ZodOptional<z.ZodString>;
+                    detailPattern: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                }, {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            }, {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            }>>;
+            emits: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            listens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                event: z.ZodString;
+                triggers: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                event: string;
+                triggers: string;
+            }, {
+                event: string;
+                triggers: string;
+            }>, "many">>;
+            relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                entity: z.ZodString;
+                alias: z.ZodOptional<z.ZodString>;
+                cardinality: z.ZodEnum<["one", "many"]>;
+            }, "strip", z.ZodTypeAny, {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }, {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            traits: string[];
+            name: string;
+            entity: {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            };
+            pages?: {
+                path: string;
+                name: string;
+                viewType: string;
+            }[] | undefined;
+            relations?: {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }[] | undefined;
+            patterns?: string[] | undefined;
+            domainContext?: {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            } | undefined;
+            design?: {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            } | undefined;
+            emits?: string[] | undefined;
+            listens?: {
+                event: string;
+                triggers: string;
+            }[] | undefined;
+        }, {
+            name: string;
+            entity: {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            };
+            pages?: {
+                path: string;
+                name: string;
+                viewType: string;
+            }[] | undefined;
+            traits?: string[] | undefined;
+            relations?: {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }[] | undefined;
+            patterns?: string[] | undefined;
+            domainContext?: {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            } | undefined;
+            design?: {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            } | undefined;
+            emits?: string[] | undefined;
+            listens?: {
+                event: string;
+                triggers: string;
+            }[] | undefined;
+        }>;
+        orbitalIndex: z.ZodOptional<z.ZodNumber>;
+        totalOrbitals: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        orbital: {
+            traits: string[];
+            name: string;
+            entity: {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            };
+            pages?: {
+                path: string;
+                name: string;
+                viewType: string;
+            }[] | undefined;
+            relations?: {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }[] | undefined;
+            patterns?: string[] | undefined;
+            domainContext?: {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            } | undefined;
+            design?: {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            } | undefined;
+            emits?: string[] | undefined;
+            listens?: {
+                event: string;
+                triggers: string;
+            }[] | undefined;
+        };
+        orbitalIndex?: number | undefined;
+        totalOrbitals?: number | undefined;
+    }, {
+        orbital: {
+            name: string;
+            entity: {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            };
+            pages?: {
+                path: string;
+                name: string;
+                viewType: string;
+            }[] | undefined;
+            traits?: string[] | undefined;
+            relations?: {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }[] | undefined;
+            patterns?: string[] | undefined;
+            domainContext?: {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            } | undefined;
+            design?: {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            } | undefined;
+            emits?: string[] | undefined;
+            listens?: {
+                event: string;
+                triggers: string;
+            }[] | undefined;
+        };
+        orbitalIndex?: number | undefined;
+        totalOrbitals?: number | undefined;
+    }>, {
+        orbital: {
+            traits: string[];
+            name: string;
+            entity: {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            };
+            pages?: {
+                path: string;
+                name: string;
+                viewType: string;
+            }[] | undefined;
+            relations?: {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }[] | undefined;
+            patterns?: string[] | undefined;
+            domainContext?: {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            } | undefined;
+            design?: {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            } | undefined;
+            emits?: string[] | undefined;
+            listens?: {
+                event: string;
+                triggers: string;
+            }[] | undefined;
+        };
+        orbitalIndex?: number | undefined;
+        totalOrbitals?: number | undefined;
+    }, {
+        orbital: {
+            name: string;
+            entity: {
+                name: string;
+                fields: {
+                    type: string;
+                    name: string;
+                    required?: boolean | undefined;
+                }[];
+                persistence: "persistent" | "runtime" | "singleton" | "instance";
+            };
+            pages?: {
+                path: string;
+                name: string;
+                viewType: string;
+            }[] | undefined;
+            traits?: string[] | undefined;
+            relations?: {
+                entity: string;
+                cardinality: "many" | "one";
+                alias?: string | undefined;
+            }[] | undefined;
+            patterns?: string[] | undefined;
+            domainContext?: {
+                request: string;
+                category: "game" | "business" | "dashboard" | "form" | "content" | "social" | "ecommerce" | "workflow";
+                requestFragment?: string | undefined;
+                vocabulary?: Record<string, string> | undefined;
+            } | undefined;
+            design?: {
+                style?: "minimal" | "modern" | "playful" | "data-driven" | "immersive" | undefined;
+                uxHints?: {
+                    flowPattern?: string | undefined;
+                    listPattern?: string | undefined;
+                    formPattern?: string | undefined;
+                    detailPattern?: string | undefined;
+                } | undefined;
+            } | undefined;
+            emits?: string[] | undefined;
+            listens?: {
+                event: string;
+                triggers: string;
+            }[] | undefined;
+        };
+        orbitalIndex?: number | undefined;
+        totalOrbitals?: number | undefined;
+    }, string, "generate_orbital">;
+    setEventCallback: (callback: SubagentEventCallback) => void;
+    setOrbitalCompleteCallback: (callback: OrbitalCompleteCallback) => void;
+};
+/**
+ * Create a helper to wrap subagent events into SSE format.
+ */
+export declare function createSubagentEventWrapper(writeEvent: (event: SSEEvent) => void): SubagentEventCallback;

package/dist/tools/orchestrated-fixing.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Orchestrated Fixing Tool
+ *
+ * Uses Plan-Then-Execute with Multi-Provider strategy for fixing:
+ * - Plan: Analyze errors and create fix plan
+ * - Execute: Apply fixes with skill context
+ * - Verify: Validate the fixed schema
+ */
+import { z } from 'zod';
+import type { OrbitalSchema } from '@almadar/core';
+export interface OrchestratedFixingOptions {
+    /** Skill content for fixing guidance (e.g., kflow-orbital-fixing SKILL.md) */
+    skillContent: string;
+    /** Optional: Max retries for fixing */
+    maxRetries?: number;
+    /** Optional: Override verbosity */
+    verbose?: boolean;
+}
+export interface OrchestratedFixingResult {
+    success: boolean;
+    schema?: OrbitalSchema;
+    fixSummary?: {
+        totalErrors: number;
+        errorsFixed: number;
+        errorsRemaining: number;
+        strategy: string;
+        stepsExecuted: number;
+    };
+    timing?: {
+        planMs: number;
+        executeMs: number;
+        verifyMs: number;
+        totalMs: number;
+    };
+    error?: string;
+}
+/**
+ * Create an orchestrated fixing tool.
+ *
+ * This tool uses Plan-Then-Execute strategy:
+ * 1. Analyze errors and create fix plan
+ * 2. Execute fixes with skill context (multi-provider for complex cases)
+ * 3. Verify and retry if needed
+ */
+export declare function createOrchestratedFixingTool(options: OrchestratedFixingOptions): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    schema: {};
+}, {
+    schema: {};
+}>, {
+    schema: {};
+}, {
+    schema: {};
+}, OrchestratedFixingResult, "fix_schema_orchestrated">;
+/**
+ * Create a validation-only tool (no fixing).
+ * Useful for checking schema validity before/after other operations.
+ */
+export declare function createValidateTool(): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    schema: {};
+}, {
+    schema: {};
+}>, {
+    schema: {};
+}, {
+    schema: {};
+}, {
+    valid: boolean;
+    errorCount: number;
+    errors: unknown[];
+}, "validate_schema">;

package/dist/tools/orchestrated-generation.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Orchestrated Generation Tool
+ *
+ * Uses the complexity-based provider router for generation:
+ * - Simple/Medium (1-3 orbitals) → Qwen
+ * - Complex (4+ orbitals) → Multi-provider parallel
+ *
+ * This tool can be used by skill agents to generate schemas
+ * with automatic provider selection based on complexity.
+ */
+import { z } from 'zod';
+export interface OrchestratedGenerationOptions {
+    /** Skill content for generation guidance */
+    skillContent: string;
+    /** Optional: Override verbosity */
+    verbose?: boolean;
+    /** Working directory for persisting schema and orbital files */
+    workDir?: string;
+}
+export interface OrchestratedGenerationResult {
+    success: boolean;
+    summary?: string;
+    orbitalCount?: number;
+    schemaPath?: string;
+    complexity?: {
+        level: 'simple' | 'medium' | 'complex';
+        orbitalCount: number;
+    };
+    provider?: string;
+    timing?: {
+        decomposeMs: number;
+        generateMs: number;
+        totalMs: number;
+    };
+    error?: string;
+}
+/**
+ * Create an orchestrated generation tool.
+ *
+ * This tool uses complexity-based routing:
+ * - Decomposes the request with Anthropic
+ * - Routes to appropriate provider(s) based on complexity
+ * - Returns the generated schema
+ */
+export declare function createOrchestratedGenerationTool(options: OrchestratedGenerationOptions): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+}, {
+    prompt: string;
+}>, {
+    prompt: string;
+}, {
+    prompt: string;
+}, OrchestratedGenerationResult, "generate_schema_orchestrated">;
+/**
+ * Create a tool that provides complexity estimation without full generation.
+ * Useful for UI feedback before starting generation.
+ */
+export declare function createComplexityCheckTool(): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+}, {
+    prompt: string;
+}>, {
+    prompt: string;
+}, {
+    prompt: string;
+}, {
+    estimatedOrbitals: number;
+    confidence: "medium" | "high" | "low";
+    likelyComplex: boolean;
+    recommendedStrategy: string;
+}, "check_complexity">;