@stephen-netu/design-system 0.1.0 → 0.2.1

package/{src → dist}/x0-enchanted-blocks/components/NodepadBlock.svelte

@@ -144,7 +144,7 @@
     position: relative;
     padding: 12px 14px;
     background: var(--color-bg-elevated, #252422);
-    border-left: 3px solid var(--type-color, #b87333);
+    border-left: 3px solid var(--type-color, var(--color-accent));
     border-radius: 0 6px 6px 0;
     /* CRITICAL: Constant dimensions - no size change on focus/hover */
     transition: box-shadow 0.15s ease, border-color 0.15s ease;
@@ -157,7 +157,7 @@
   
   .nodepad-block:focus-within {
     /* Use outline instead of border change to avoid layout shift */
-    outline: 2px solid color-mix(in srgb, var(--type-color, #b87333) 50%, transparent);
+    outline: 2px solid color-mix(in srgb, var(--type-color, var(--color-accent)) 50%, transparent);
     outline-offset: 2px;
   }
   
@@ -171,28 +171,28 @@
     align-items: center;
     justify-content: space-between;
     margin-bottom: 8px;
-    gap: 8px;
+    gap: var(--space-2);
   }
   
   .type-chip {
     display: inline-flex;
     align-items: center;
-    gap: 4px;
-    padding: 2px 8px;
-    background: color-mix(in srgb, var(--type-color, #b87333) 15%, transparent);
-    border: 1px solid color-mix(in srgb, var(--type-color, #b87333) 25%, transparent);
+    gap: var(--space-1);
+    padding: 2px var(--space-2);
+    background: color-mix(in srgb, var(--type-color, var(--color-accent)) 15%, transparent);
+    border: 1px solid color-mix(in srgb, var(--type-color, var(--color-accent)) 25%, transparent);
     border-radius: 4px;
     font-size: 11px;
     font-weight: 500;
-    color: var(--type-color, #b87333);
+    color: var(--type-color, var(--color-accent));
     cursor: pointer;
     transition: all 0.15s ease;
     font-family: inherit;
   }
   
   .type-chip:hover {
-    background: color-mix(in srgb, var(--type-color, #b87333) 25%, transparent);
-    border-color: color-mix(in srgb, var(--type-color, #b87333) 50%, transparent);
+    background: color-mix(in srgb, var(--type-color, var(--color-accent)) 25%, transparent);
+    border-color: color-mix(in srgb, var(--type-color, var(--color-accent)) 50%, transparent);
   }
   
   .type-icon {
@@ -218,7 +218,7 @@
     word-break: break-word;
     min-height: 1.6em;
     outline: none;
-    caret-color: var(--type-color, #b87333);
+    caret-color: var(--type-color, var(--color-accent));
   }
   
   .block-content:empty::before {
@@ -239,7 +239,7 @@
   }
   
   .annotation-dot {
-    color: var(--type-color, #b87333);
+    color: var(--type-color, var(--color-accent));
     margin-right: 4px;
   }
   
@@ -251,7 +251,7 @@
     width: 6px;
     height: 6px;
     border-radius: 50%;
-    background: var(--type-color, #b87333);
+    background: var(--type-color, var(--color-accent));
     animation: pulse 1.5s infinite;
   }
   

package/dist/x0-enchanted-blocks/components/NodepadBlock.svelte.d.ts

@@ -0,0 +1,11 @@
+import { type BlockType, type EnchantedBlockData } from '../core/block-types.js';
+interface Props {
+    block: EnchantedBlockData;
+    maxWidth?: number;
+    onChange?: (content: string) => void;
+    onTypeChange?: (type: BlockType) => void;
+}
+declare const NodepadBlock: import("svelte").Component<Props, {}, "">;
+type NodepadBlock = ReturnType<typeof NodepadBlock>;
+export default NodepadBlock;
+//# sourceMappingURL=NodepadBlock.svelte.d.ts.map

package/dist/x0-enchanted-blocks/components/NodepadBlock.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodepadBlock.svelte.d.ts","sourceRoot":"","sources":["../../../src/x0-enchanted-blocks/components/NodepadBlock.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EACH,KAAK,SAAS,EACd,KAAK,kBAAkB,EAIxB,MAAM,wBAAwB,CAAC;AAGhC,UAAU,KAAK;IACb,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CAC1C;AAqHH,QAAA,MAAM,YAAY,2CAAwC,CAAC;AAC3D,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACpD,eAAe,YAAY,CAAC"}

package/dist/x0-enchanted-blocks/core/block-layout.d.ts

@@ -0,0 +1,79 @@
+/** Layout options for text measurement */
+export interface LayoutOptions {
+    /** White space handling: 'normal' (collapse) or 'pre-wrap' (preserve) */
+    whiteSpace?: 'normal' | 'pre-wrap';
+    /** Word breaking: 'normal' (break at word boundaries) or 'keep-all' (CJK/Hangul) */
+    wordBreak?: 'normal' | 'keep-all';
+}
+/** Metrics returned from block measurement */
+export interface BlockMetrics {
+    /** Minimum width before text wraps to additional lines (shrink-wrap) */
+    minWidth: number;
+    /** Optimal reading width (~65 characters) */
+    idealWidth: number;
+    /** Total height at the measured width */
+    height: number;
+    /** Number of lines at the measured width */
+    lineCount: number;
+    /** True if content exceeds reasonable display limits */
+    hasOverflow: boolean;
+    /** The font string used for measurement */
+    font: string;
+}
+/** Default font configuration matching KOS design system */
+export declare const DEFAULT_FONT = "14px \"Sovereign Sans\", system-ui, -apple-system, sans-serif";
+/** Default monospace font for code/preformatted content */
+export declare const DEFAULT_MONO_FONT = "13px \"Sovereign Mono\", \"SF Mono\", Monaco, \"Cascadia Code\", monospace";
+/** Ideal reading width in pixels (~65ch at 14px) */
+export declare const IDEAL_READING_WIDTH = 520;
+/** Maximum reasonable block height before overflow indicator */
+export declare const MAX_BLOCK_HEIGHT = 400;
+/** Maximum characters before overflow detection */
+export declare const MAX_CONTENT_LENGTH = 5000;
+/**
+ * Measure block content using Pretext's DOM-free layout engine.
+ *
+ * This function uses canvas-based text measurement for accurate sizing
+ * without triggering DOM layout/reflow cycles.
+ *
+ * @param content - The text content to measure
+ * @param font - Font specification string (defaults to DEFAULT_FONT)
+ * @param maxWidth - Maximum container width constraint
+ * @param options - Layout options (whiteSpace, wordBreak)
+ * @param lineHeight - Line height multiplier (default: 1.6)
+ * @returns BlockMetrics with sizing information
+ *
+ * @example
+ * ```typescript
+ * const metrics = measureBlock(
+ *   'Task: Implement authentication system with OAuth2 support',
+ *   '14px Inter',
+ *   400,
+ *   { whiteSpace: 'normal' }
+ * );
+ * // metrics.height → precise pixel height
+ * // metrics.lineCount → number of wrapped lines
+ * ```
+ */
+export declare function measureBlock(content: string, font?: string, maxWidth?: number, options?: LayoutOptions, lineHeight?: number): BlockMetrics;
+/**
+ * Quick measurement for content previews (truncated at first overflow).
+ * Returns faster results for long content by sampling first N characters.
+ */
+export declare function measureBlockPreview(content: string, font?: string, maxWidth?: number, maxLines?: number): BlockMetrics;
+/**
+ * Measure multiple blocks efficiently with shared font preparation.
+ * Useful for virtualized lists where font is constant.
+ */
+export declare function measureBlocksBatch(contents: string[], font?: string, maxWidth?: number): BlockMetrics[];
+/**
+ * Calculate total canvas height for a collection of blocks.
+ * Includes spacing between blocks.
+ */
+export declare function calculateCanvasHeight(metrics: BlockMetrics[], spacing?: number, padding?: number): number;
+/**
+ * Determine optimal column width for kanban-style layouts.
+ * Balances content width against container constraints.
+ */
+export declare function calculateOptimalColumnWidth(allMetrics: BlockMetrics[], containerWidth: number, columnCount: number, minColumnWidth?: number): number;
+//# sourceMappingURL=block-layout.d.ts.map

package/dist/x0-enchanted-blocks/core/block-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-layout.d.ts","sourceRoot":"","sources":["../../../src/x0-enchanted-blocks/core/block-layout.ts"],"names":[],"mappings":"AAKA,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,UAAU,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IACnC,oFAAoF;IACpF,SAAS,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;CACnC;AAED,8CAA8C;AAC9C,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,WAAW,EAAE,OAAO,CAAC;IACrB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd;AAED,4DAA4D;AAC5D,eAAO,MAAM,YAAY,kEAAgE,CAAC;AAE1F,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB,+EAAyE,CAAC;AAExG,oDAAoD;AACpD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,gEAAgE;AAChE,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,mDAAmD;AACnD,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAqB,EAC3B,QAAQ,GAAE,MAA4B,EACtC,OAAO,GAAE,aAAkB,EAC3B,UAAU,GAAE,MAAY,GACvB,YAAY,CA2Dd;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,MAAqB,EAC3B,QAAQ,GAAE,MAA4B,EACtC,QAAQ,GAAE,MAAW,GACpB,YAAY,CAoBd;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAAE,EAClB,IAAI,GAAE,MAAqB,EAC3B,QAAQ,GAAE,MAA4B,GACrC,YAAY,EAAE,CAEhB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,GAAE,MAAW,EACpB,OAAO,GAAE,MAAW,GACnB,MAAM,CAIR;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,YAAY,EAAE,EAC1B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,cAAc,GAAE,MAAY,GAC3B,MAAM,CAQR"}

package/dist/x0-enchanted-blocks/core/block-layout.js

@@ -0,0 +1,135 @@
+// Block Layout Engine — DOM-free text measurement using Pretext
+// Provides accurate sizing for adaptive block rendering
+import { prepareWithSegments, layout, measureNaturalWidth as pretextMeasureNatural } from '@chenglou/pretext';
+/** Default font configuration matching KOS design system */
+export const DEFAULT_FONT = '14px "Sovereign Sans", system-ui, -apple-system, sans-serif';
+/** Default monospace font for code/preformatted content */
+export const DEFAULT_MONO_FONT = '13px "Sovereign Mono", "SF Mono", Monaco, "Cascadia Code", monospace';
+/** Ideal reading width in pixels (~65ch at 14px) */
+export const IDEAL_READING_WIDTH = 520;
+/** Maximum reasonable block height before overflow indicator */
+export const MAX_BLOCK_HEIGHT = 400;
+/** Maximum characters before overflow detection */
+export const MAX_CONTENT_LENGTH = 5000;
+/**
+ * Measure block content using Pretext's DOM-free layout engine.
+ *
+ * This function uses canvas-based text measurement for accurate sizing
+ * without triggering DOM layout/reflow cycles.
+ *
+ * @param content - The text content to measure
+ * @param font - Font specification string (defaults to DEFAULT_FONT)
+ * @param maxWidth - Maximum container width constraint
+ * @param options - Layout options (whiteSpace, wordBreak)
+ * @param lineHeight - Line height multiplier (default: 1.6)
+ * @returns BlockMetrics with sizing information
+ *
+ * @example
+ * ```typescript
+ * const metrics = measureBlock(
+ *   'Task: Implement authentication system with OAuth2 support',
+ *   '14px Inter',
+ *   400,
+ *   { whiteSpace: 'normal' }
+ * );
+ * // metrics.height → precise pixel height
+ * // metrics.lineCount → number of wrapped lines
+ * ```
+ */
+export function measureBlock(content, font = DEFAULT_FONT, maxWidth = IDEAL_READING_WIDTH, options = {}, lineHeight = 1.6) {
+    // SSR Safety: Pretext requires DOM/Canvas. Return safe defaults if run on server.
+    if (typeof window === 'undefined') {
+        return {
+            minWidth: 0,
+            idealWidth: Math.min(IDEAL_READING_WIDTH, maxWidth),
+            height: lineHeight * 14,
+            lineCount: 1,
+            hasOverflow: false,
+            font,
+        };
+    }
+    // Handle empty content
+    if (!content || content.length === 0) {
+        return {
+            minWidth: 0,
+            idealWidth: Math.min(IDEAL_READING_WIDTH, maxWidth),
+            height: lineHeight * 14, // One line height
+            lineCount: 1,
+            hasOverflow: false,
+            font,
+        };
+    }
+    // Truncate extremely long content to prevent performance issues
+    const truncatedContent = content.length > MAX_CONTENT_LENGTH
+        ? content.slice(0, MAX_CONTENT_LENGTH) + '…'
+        : content;
+    // Prepare text for measurement (one-time work)
+    const prepared = prepareWithSegments(truncatedContent, font, {
+        whiteSpace: options.whiteSpace ?? 'normal',
+        wordBreak: options.wordBreak ?? 'normal',
+    });
+    // Measure at the target width
+    const { height, lineCount } = layout(prepared, maxWidth, lineHeight);
+    // Calculate shrink-wrap width (tightest fit)
+    const minWidth = pretextMeasureNatural(prepared);
+    // Determine ideal width (between min and max, capped at reading width)
+    const idealWidth = Math.min(Math.max(minWidth, Math.min(IDEAL_READING_WIDTH, maxWidth)), maxWidth);
+    // Detect overflow conditions
+    const hasOverflow = height > MAX_BLOCK_HEIGHT || content.length > MAX_CONTENT_LENGTH;
+    return {
+        minWidth,
+        idealWidth,
+        height,
+        lineCount,
+        hasOverflow,
+        font,
+    };
+}
+/**
+ * Quick measurement for content previews (truncated at first overflow).
+ * Returns faster results for long content by sampling first N characters.
+ */
+export function measureBlockPreview(content, font = DEFAULT_FONT, maxWidth = IDEAL_READING_WIDTH, maxLines = 10) {
+    const previewLength = 1000; // Sample size for preview
+    const previewContent = content.length > previewLength
+        ? content.slice(0, previewLength) + '…'
+        : content;
+    const metrics = measureBlock(previewContent, font, maxWidth);
+    // Cap line count for preview
+    if (metrics.lineCount > maxLines) {
+        const lineHeight = 1.6 * 14; // approximate
+        return {
+            ...metrics,
+            lineCount: maxLines,
+            height: maxLines * lineHeight,
+            hasOverflow: true,
+        };
+    }
+    return { ...metrics, hasOverflow: content.length > previewLength };
+}
+/**
+ * Measure multiple blocks efficiently with shared font preparation.
+ * Useful for virtualized lists where font is constant.
+ */
+export function measureBlocksBatch(contents, font = DEFAULT_FONT, maxWidth = IDEAL_READING_WIDTH) {
+    return contents.map(content => measureBlock(content, font, maxWidth));
+}
+/**
+ * Calculate total canvas height for a collection of blocks.
+ * Includes spacing between blocks.
+ */
+export function calculateCanvasHeight(metrics, spacing = 16, padding = 24) {
+    const contentHeight = metrics.reduce((sum, m) => sum + m.height, 0);
+    const spacingHeight = Math.max(0, metrics.length - 1) * spacing;
+    return padding * 2 + contentHeight + spacingHeight;
+}
+/**
+ * Determine optimal column width for kanban-style layouts.
+ * Balances content width against container constraints.
+ */
+export function calculateOptimalColumnWidth(allMetrics, containerWidth, columnCount, minColumnWidth = 280) {
+    const maxContentWidth = Math.max(...allMetrics.map(m => m.minWidth));
+    const availableWidth = (containerWidth - (columnCount - 1) * 16) / columnCount;
+    return Math.max(minColumnWidth, Math.min(maxContentWidth + 48, availableWidth) // +48 for padding
+    );
+}

package/dist/x0-enchanted-blocks/core/block-types.d.ts

@@ -0,0 +1,56 @@
+/** The 14 types of enchanted blocks for spatial research */
+export type BlockType = 'claim' | 'question' | 'idea' | 'task' | 'entity' | 'quote' | 'reference' | 'definition' | 'opinion' | 'reflection' | 'narrative' | 'comparison' | 'thesis' | 'general';
+/** All block types as an array for iteration */
+export declare const ALL_BLOCK_TYPES: BlockType[];
+/** Human-readable labels for each block type */
+export declare const BLOCK_TYPE_LABELS: Record<BlockType, string>;
+/** Lucide icon names for each block type */
+export declare const BLOCK_TYPE_ICONS: Record<BlockType, string>;
+/**
+ * CSS color tokens for each block type.
+ * Uses KOS brass/copper palette with semantic differentiation.
+ * Format: HSL values for --type-color CSS custom property.
+ */
+export declare const BLOCK_TYPE_COLORS: Record<BlockType, string>;
+/** Get the next type in sequence (for cycling via click) */
+export declare function nextBlockType(current: BlockType): BlockType;
+/** Get the previous type in sequence */
+export declare function prevBlockType(current: BlockType): BlockType;
+/**
+ * Simple heuristic classifier based on content patterns.
+ * Returns confidence score 0-1 alongside type.
+ */
+export declare function classifyBlockHeuristic(content: string): {
+    type: BlockType;
+    confidence: number;
+};
+/** Core data structure for an enchanted block */
+export interface EnchantedBlockData {
+    id: string;
+    type: BlockType;
+    content: string;
+    /** AI-generated annotation: "what the note doesn't say" */
+    annotation?: string;
+    /** Epistemic provenance from KVE */
+    provenance?: {
+        source: string;
+        createdAt: number;
+        modifiedAt: number;
+        confidence?: number;
+    };
+    /** Inferred connections to other blocks */
+    connections?: {
+        targetId: string;
+        strength: number;
+        type: 'supports' | 'contradicts' | 'extends' | 'similar' | 'related';
+    }[];
+    /** Spatial position (for canvas views) */
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    /** Timestamps */
+    createdAt: number;
+    modifiedAt: number;
+}
+//# sourceMappingURL=block-types.d.ts.map

package/dist/x0-enchanted-blocks/core/block-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-types.d.ts","sourceRoot":"","sources":["../../../src/x0-enchanted-blocks/core/block-types.ts"],"names":[],"mappings":"AAGA,4DAA4D;AAC5D,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,UAAU,GACV,MAAM,GACN,MAAM,GACN,QAAQ,GACR,OAAO,GACP,WAAW,GACX,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,QAAQ,GACR,SAAS,CAAC;AAEd,gDAAgD;AAChD,eAAO,MAAM,eAAe,EAAE,SAAS,EAetC,CAAC;AAEF,gDAAgD;AAChD,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAevD,CAAC;AAEF,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAetD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAwBvD,CAAC;AAEF,4DAA4D;AAC5D,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAG3D;AAED,wCAAwC;AACxC,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAG3D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAsE/F;AAED,iDAAiD;AACjD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,oCAAoC;IACpC,UAAU,CAAC,EAAE;QACX,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IAEF,2CAA2C;IAC3C,WAAW,CAAC,EAAE;QACZ,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;KACtE,EAAE,CAAC;IAEJ,0CAA0C;IAC1C,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/x0-enchanted-blocks/core/block-types.js

@@ -0,0 +1,151 @@
+// Block Types — 14 spatial research classifications
+// Based on Nodepad's auto-classification system
+/** All block types as an array for iteration */
+export const ALL_BLOCK_TYPES = [
+    'claim',
+    'question',
+    'idea',
+    'task',
+    'entity',
+    'quote',
+    'reference',
+    'definition',
+    'opinion',
+    'reflection',
+    'narrative',
+    'comparison',
+    'thesis',
+    'general',
+];
+/** Human-readable labels for each block type */
+export const BLOCK_TYPE_LABELS = {
+    claim: 'Claim',
+    question: 'Question',
+    idea: 'Idea',
+    task: 'Task',
+    entity: 'Entity',
+    quote: 'Quote',
+    reference: 'Reference',
+    definition: 'Definition',
+    opinion: 'Opinion',
+    reflection: 'Reflection',
+    narrative: 'Narrative',
+    comparison: 'Comparison',
+    thesis: 'Thesis',
+    general: 'Note',
+};
+/** Lucide icon names for each block type */
+export const BLOCK_TYPE_ICONS = {
+    claim: 'CheckCircle', // Asserted truth
+    question: 'HelpCircle', // Inquiry
+    idea: 'Lightbulb', // Concept
+    task: 'CheckSquare', // Action item
+    entity: 'Box', // Named thing
+    quote: 'Quote', // Citation
+    reference: 'Link', // Pointer
+    definition: 'BookOpen', // Explanation
+    opinion: 'MessageCircle', // Subjective view
+    reflection: 'Mirror', // Self-aware
+    narrative: 'ScrollText', // Story
+    comparison: 'Scale', // Analysis
+    thesis: 'GraduationCap', // Synthesized argument
+    general: 'StickyNote', // Default
+};
+/**
+ * CSS color tokens for each block type.
+ * Uses KOS brass/copper palette with semantic differentiation.
+ * Format: HSL values for --type-color CSS custom property.
+ */
+export const BLOCK_TYPE_COLORS = {
+    // Warm/assertive types (brass/gold variants)
+    claim: 'hsl(30, 60%, 55%)', // Brass
+    thesis: 'hsl(25, 70%, 50%)', // Copper
+    task: 'hsl(35, 55%, 50%)', // Bronze
+    // Cool/inquisitive types (muted complementary)
+    question: 'hsl(210, 50%, 60%)', // Steel blue
+    idea: 'hsl(160, 45%, 50%)', // Sage
+    opinion: 'hsl(280, 40%, 55%)', // Muted purple
+    // Reference/external types (neutral)
+    quote: 'hsl(0, 0%, 70%)', // Silver
+    reference: 'hsl(200, 30%, 60%)', // Slate
+    definition: 'hsl(180, 35%, 55%)', // Teal
+    // Process/meta types (warm earth)
+    reflection: 'hsl(45, 50%, 55%)', // Amber
+    narrative: 'hsl(20, 45%, 50%)', // Terracotta
+    comparison: 'hsl(40, 45%, 50%)', // Gold ochre
+    // Structural types
+    entity: 'hsl(220, 40%, 55%)', // Denim
+    general: 'hsl(30, 40%, 50%)', // Default brass
+};
+/** Get the next type in sequence (for cycling via click) */
+export function nextBlockType(current) {
+    const idx = ALL_BLOCK_TYPES.indexOf(current);
+    return ALL_BLOCK_TYPES[(idx + 1) % ALL_BLOCK_TYPES.length];
+}
+/** Get the previous type in sequence */
+export function prevBlockType(current) {
+    const idx = ALL_BLOCK_TYPES.indexOf(current);
+    return ALL_BLOCK_TYPES[(idx - 1 + ALL_BLOCK_TYPES.length) % ALL_BLOCK_TYPES.length];
+}
+/**
+ * Simple heuristic classifier based on content patterns.
+ * Returns confidence score 0-1 alongside type.
+ */
+export function classifyBlockHeuristic(content) {
+    const lower = content.toLowerCase().trim();
+    // Question detection
+    if (lower.match(/^(what|why|how|when|where|who|is\s+it|are\s+they|can\s+we|should\s+we)\b/i) ||
+        lower.endsWith('?')) {
+        return { type: 'question', confidence: 0.9 };
+    }
+    // Task detection
+    if (lower.match(/^(todo|task|action|implement|fix|add|remove|update|create|build)\b/i) ||
+        lower.match(/\[x\]|\[ \]|\[-\]/)) {
+        return { type: 'task', confidence: 0.85 };
+    }
+    // Quote detection
+    if (lower.startsWith('"') && lower.includes('"') ||
+        lower.startsWith('"') && lower.endsWith('"') ||
+        lower.match(/^as\s+\w+\s+said/i)) {
+        return { type: 'quote', confidence: 0.8 };
+    }
+    // Definition detection
+    if (lower.match(/\bis\s+(defined\s+as|a\s+type\s+of|the\s+process\s+of)\b/i) ||
+        lower.match(/^\w+:\s+\w+/)) {
+        return { type: 'definition', confidence: 0.75 };
+    }
+    // Claim detection (assertive language)
+    if (lower.match(/\b(is|are|will|must|should|always|never|proves|shows|demonstrates)\b/i) &&
+        !lower.endsWith('?')) {
+        return { type: 'claim', confidence: 0.7 };
+    }
+    // Idea detection
+    if (lower.match(/\b(idea|concept|proposal|suggest|consider|perhaps|maybe|could|might)\b/i)) {
+        return { type: 'idea', confidence: 0.65 };
+    }
+    // Reference detection
+    if (lower.match(/^(see|cf\.|refer\s+to|check\s+out|read|http|www\.|github\.com)/i)) {
+        return { type: 'reference', confidence: 0.8 };
+    }
+    // Narrative detection (time words)
+    if (lower.match(/\b(then|next|after|before|finally|eventually|once|when\s+we)\b/i)) {
+        return { type: 'narrative', confidence: 0.6 };
+    }
+    // Comparison detection
+    if (lower.match(/\b(vs|versus|compared\s+to|unlike|similarly|both|either|or)\b/i)) {
+        return { type: 'comparison', confidence: 0.65 };
+    }
+    // Reflection detection (self-aware)
+    if (lower.match(/\b(i\s+think|i\s+wonder|i\s+realized|reflecting|thinking\s+about)\b/i)) {
+        return { type: 'reflection', confidence: 0.7 };
+    }
+    // Opinion detection
+    if (lower.match(/\b(i\s+believe|in\s+my\s+opinion|personally|i\s+feel|i\s+prefer)\b/i)) {
+        return { type: 'opinion', confidence: 0.75 };
+    }
+    // Entity detection (proper nouns, capitalized)
+    if (lower.match(/^[A-Z][a-z]+\s+(is|was|are|refers\s+to)/)) {
+        return { type: 'entity', confidence: 0.6 };
+    }
+    return { type: 'general', confidence: 0.5 };
+}

package/dist/x0-enchanted-blocks/index.d.ts

@@ -0,0 +1,7 @@
+export { measureBlock, measureBlockPreview, measureBlocksBatch, calculateCanvasHeight, calculateOptimalColumnWidth, DEFAULT_FONT, DEFAULT_MONO_FONT, IDEAL_READING_WIDTH, MAX_BLOCK_HEIGHT, MAX_CONTENT_LENGTH, } from './core/block-layout.js';
+export type { BlockMetrics, LayoutOptions, } from './core/block-layout.js';
+export { ALL_BLOCK_TYPES, BLOCK_TYPE_LABELS, BLOCK_TYPE_ICONS, BLOCK_TYPE_COLORS, nextBlockType, prevBlockType, classifyBlockHeuristic, } from './core/block-types.js';
+export type { BlockType, EnchantedBlockData, } from './core/block-types.js';
+export { default as EnchantedBlock } from './components/EnchantedBlock.svelte';
+export { default as NodepadBlock } from './components/NodepadBlock.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/x0-enchanted-blocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/x0-enchanted-blocks/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,2BAA2B,EAC3B,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,YAAY,EACZ,aAAa,GACd,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,SAAS,EACT,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/x0-enchanted-blocks/index.js

@@ -0,0 +1,13 @@
+// X0 Enchanted Blocks — Adaptive spatial content system
+// Phase 1: Foundation (measurement + adaptive sizing)
+// Core primitives
+export { measureBlock, measureBlockPreview, measureBlocksBatch, calculateCanvasHeight, calculateOptimalColumnWidth, DEFAULT_FONT, DEFAULT_MONO_FONT, IDEAL_READING_WIDTH, MAX_BLOCK_HEIGHT, MAX_CONTENT_LENGTH, } from './core/block-layout.js';
+// Block types and classification
+export { ALL_BLOCK_TYPES, BLOCK_TYPE_LABELS, BLOCK_TYPE_ICONS, BLOCK_TYPE_COLORS, nextBlockType, prevBlockType, classifyBlockHeuristic, } from './core/block-types.js';
+// Components
+export { default as EnchantedBlock } from './components/EnchantedBlock.svelte';
+export { default as NodepadBlock } from './components/NodepadBlock.svelte';
+// Future exports (Phase 2-5):
+// export { useBlockEnrichment } from './hooks/useBlockEnrichment.svelte.js';
+// export { default as EnchantedCanvas } from './components/EnchantedCanvas.svelte';
+// export { classifyBlockLLM } from './core/classifier.js';