@almadar/ui 6.56.0 → 6.58.0

package/dist/{cn-ClXGlIOY.d.ts → cn-DIql5232.d.ts}

@@ -1,7 +1,17 @@
-import { OrbitalSchema, A11yProps } from '@almadar/core';
+import { OrbitalSchema, A11yProps, EventEmit } from '@almadar/core';
 import React__default from 'react';
 import { ClassValue } from 'clsx';
 
+type AnnotationKind = 'question' | 'note';
+interface ContentAnnotation {
+    /** Unique id, echoed in the click event payload */
+    id: string;
+    /** Exact passage to highlight (first occurrence in the rendered text) */
+    text: string;
+    /** Highlight colour: `question` or `note` */
+    kind: AnnotationKind;
+}
+
 /**
  * Pure vim-flavored editor motion module. No DOM — `CodeBlock.tsx` drives a
  * real `<textarea>` selection through this (Almadar Studio V4 §14 plan, P1
@@ -85,7 +95,7 @@ type ContentSegment = {
  * Splits markdown into segments of plain markdown and fenced code blocks.
  * JSON/orb code blocks containing orbital schemas are tagged as 'orbital'.
  */
-declare function parseMarkdownWithCodeBlocks$1(content: string | undefined | null): ContentSegment[];
+declare function parseMarkdownWithCodeBlocks(content: string | undefined | null): ContentSegment[];
 /**
  * Parse content to extract all segments including quiz tags and code blocks.
  *
@@ -123,37 +133,72 @@ interface BloomQuizBlockProps extends A11yProps {
 declare const BloomQuizBlock: React__default.FC<BloomQuizBlockProps>;
 
 /**
- * Utility for lesson-segment parsing: splits a markdown string into alternating
- * markdown and fenced-code-block segments. Exported so SegmentRenderer and
- * BloomQuizBlock can reuse without circular imports.
+ * CodeRunnerPanel Organism Component
+ *
+ * Editable code block with Run/Reset buttons and simulated terminal output.
+ * Real execution is a future concern; callers supply a simulation function via
+ * `onRun`. Emits `UI:RUN_CODE { language, exitCode }` on every run attempt.
+ *
+ * Event Contract:
+ * - Emits: UI:RUN_CODE { language, exitCode, error? }
+ * - entityAware: false
  */
-type MarkdownSegment = {
-    type: 'markdown';
-    content: string;
-};
-type CodeSegment = {
-    type: 'code';
+
+interface CodeSimulationOutput {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    testResults: Array<{
+        input: string;
+        expectedOutput: string;
+        actualOutput: string;
+        passed: boolean;
+    }>;
+}
+interface CodeRunnerPanelProps extends Omit<React__default.AriaAttributes, keyof A11yProps>, A11yProps {
+    /** Initial code content */
+    code: string;
+    /** Programming language for syntax highlighting */
     language: string;
-    content: string;
+    /** Whether the panel allows running (false = read-only code block) */
     runnable?: boolean;
-};
-type MixedSegment = MarkdownSegment | CodeSegment;
-/** Splits markdown content into markdown and fenced-code-block segments. */
-declare function parseMarkdownWithCodeBlocks(content: string): MixedSegment[];
+    /**
+     * Simulate executing the code. Omit to render a read-only block.
+     * Real execution is a separate future track — this callback supplies
+     * deterministic simulated output for UI feedback.
+     */
+    onRun?: (code: string) => Promise<CodeSimulationOutput>;
+    /** Event name to emit on run (emitted as `UI:<runEvent>`). Defaults to 'RUN_CODE'. */
+    runEvent?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const CodeRunnerPanel: React__default.FC<CodeRunnerPanelProps>;
 
 /**
- * parseLessonSegments — parses lesson markdown with embedded learning-science
- * XML-style tags into a typed Segment array.
+ * SegmentRenderer Organism Component
  *
- * Supported tags: <activate>, <connect>, <reflect>, <bloom level="...">,
- * <question>/<answer>, <visualize type="..." description="..." />.
+ * Renders a parsed array of LessonSegments — markdown, code, quizzes,
+ * activation prompts, connections, reflections, Bloom questions.
+ * The `visualization` segment type is passed through as a no-op unless the
+ * caller provides `onRenderVisualization` (future extensibility hook).
  *
- * Tags may be open (unclosed) — the parser falls back to consuming content
- * until the next recognised tag, a section heading (`\n\n#`), or end-of-input.
+ * Event Contract:
+ * - Delegates to child molecules: UI:{activationSaveEvent|SAVE_ACTIVATION}, UI:{reflectionSaveEvent|SAVE_REFLECTION}, UI:{bloomAnswerEvent|ANSWER_BLOOM}
+ * - Emits (selection / highlights): UI:{askEvent} { selectedText }, UI:{noteEvent} { selectedText }, UI:{annotationEvent} { annotationId }
+ * - entityAware: false
  */
 
 type InteractiveOrbitalType = 'algorithms' | 'math' | 'physics' | 'biology' | 'chemistry' | 'probability';
-type LessonSegment = MixedSegment | {
+type LessonSegment = {
+    type: 'markdown';
+    content: string;
+} | {
+    type: 'code';
+    language: string;
+    content: string;
+    runnable?: boolean;
+} | {
     type: 'quiz';
     question: string;
     answer: string;
@@ -176,6 +221,89 @@ type LessonSegment = MixedSegment | {
     visualizationType: InteractiveOrbitalType;
     description: string;
 };
+/**
+ * User progress state passed into SegmentRenderer. Declared here (rather than
+ * alongside `LessonSegment` in `lib/parseLessonSegments.ts`) so the
+ * pattern-sync scanner — which only indexes types under `components/**` —
+ * can resolve it to a concrete `.lolo` object shape instead of `json`.
+ */
+interface LessonUserProgress {
+    activationResponse?: string;
+    reflectionNotes?: string[];
+    bloomAnswered?: Record<number, boolean>;
+}
+interface SegmentRendererProps extends Omit<React__default.AriaAttributes, keyof A11yProps>, A11yProps {
+    /** Parsed lesson segments (see `parseLessonSegments`). Ignored when `lesson` is given. */
+    segments?: LessonSegment[];
+    /** Raw lesson markdown with learning tags; parsed with `parseLessonSegments` and rendered */
+    lesson?: string;
+    /** Event emitted when the activation prompt is saved or skipped (as `UI:<activationSaveEvent>`) */
+    activationSaveEvent?: EventEmit<{
+        response: string;
+    }>;
+    /** Event emitted when a reflection note is saved (as `UI:<reflectionSaveEvent>`) */
+    reflectionSaveEvent?: EventEmit<{
+        index: number;
+        note: string;
+    }>;
+    /** Event emitted on the first reveal of a Bloom question (as `UI:<bloomAnswerEvent>`) */
+    bloomAnswerEvent?: EventEmit<{
+        index: number;
+        level: BloomLevel;
+    }>;
+    /** Event emitted when the reader picks Ask on selected text (as `UI:<askEvent>`) */
+    askEvent?: EventEmit<{
+        selectedText: string;
+    }>;
+    /** Event emitted when the reader picks Note on selected text (as `UI:<noteEvent>`) */
+    noteEvent?: EventEmit<{
+        selectedText: string;
+    }>;
+    /** Ask action label (default: translated) */
+    askLabel?: string;
+    /** Note action label (default: translated) */
+    noteLabel?: string;
+    /**
+     * Passages to highlight. Each `text` is matched exactly against the markdown
+     * segments, first segment whose source contains it, first occurrence inside one
+     * rendered text node (outside code); one that spans formatting is not highlighted.
+     */
+    annotations?: ContentAnnotation[];
+    /** Event emitted when a highlighted passage is clicked (as `UI:<annotationEvent>`) */
+    annotationEvent?: EventEmit<{
+        annotationId?: string;
+    }>;
+    /** Additional CSS classes for the root container */
+    className?: string;
+    /** CSS classes for the outer wrapping div */
+    containerClassName?: string;
+    /** User progress for restoring activation/reflection state */
+    userProgress?: LessonUserProgress;
+    /**
+     * Simulate executing runnable code blocks. Omit to render runnable blocks
+     * as read-only. Real execution is a future track.
+     */
+    onRunCodeSimulation?: (code: string, language: string) => Promise<CodeSimulationOutput>;
+    /**
+     * Optional render slot for `visualization` segment types. When not provided,
+     * visualization segments are silently skipped. Callers can wire this to any
+     * custom component or orbital generator.
+     */
+    onRenderVisualization?: (type: InteractiveOrbitalType, description: string, index: number) => React__default.ReactNode;
+}
+declare const SegmentRenderer: React__default.FC<SegmentRendererProps>;
+
+/**
+ * parseLessonSegments — parses lesson markdown with embedded learning-science
+ * XML-style tags into a typed Segment array.
+ *
+ * Supported tags: <activate>, <connect>, <reflect>, <bloom level="...">,
+ * <question>/<answer>, <visualize type="..." description="..." />.
+ *
+ * Tags may be open (unclosed) — the parser falls back to consuming content
+ * until the next recognised tag, a section heading (`\n\n#`), or end-of-input.
+ */
+
 /** Parse a lesson string into typed segments. Returns `[]` when input is empty. */
 declare function parseLessonSegments(lesson: string | undefined): LessonSegment[];
 
@@ -185,4 +313,4 @@ declare function parseLessonSegments(lesson: string | undefined): LessonSegment[
  */
 declare function cn(...inputs: ClassValue[]): string;
 
-export { type ApplyOperatorInput as A, type BloomLevel as B, type ContentSegment as C, EDITOR_MOTIONS as E, INDENT_UNIT as I, type LessonSegment as L, type MixedSegment as M, type ApplyOperatorResult as a, EDITOR_OPERATORS as b, type EditorMotion as c, type EditorOperator as d, applyMotion as e, applyOperator as f, cn as g, isEditorOperator as h, isEditorMotion as i, parseLessonSegments as j, parseMarkdownWithCodeBlocks$1 as k, type InteractiveOrbitalType as l, motionRange as m, BloomQuizBlock as n, type BloomQuizBlockProps as o, parseContentSegments as p, parseMarkdownWithCodeBlocks as q };
+export { type ApplyOperatorInput as A, type BloomLevel as B, type ContentSegment as C, EDITOR_MOTIONS as E, INDENT_UNIT as I, type LessonSegment as L, SegmentRenderer as S, type ApplyOperatorResult as a, EDITOR_OPERATORS as b, type EditorMotion as c, type EditorOperator as d, applyMotion as e, applyOperator as f, cn as g, isEditorOperator as h, isEditorMotion as i, parseLessonSegments as j, parseMarkdownWithCodeBlocks as k, type ContentAnnotation as l, motionRange as m, BloomQuizBlock as n, type BloomQuizBlockProps as o, parseContentSegments as p, CodeRunnerPanel as q, type CodeRunnerPanelProps as r, type CodeSimulationOutput as s, type LessonUserProgress as t, type SegmentRendererProps as u };