@iyulab/m3l 0.1.2 → 0.1.4

package/README.md

@@ -1,6 +1,10 @@
 # @iyulab/m3l
 
-M3L (Meta Model Markup Language) parser and CLI — parse `.m3l.md` files into a structured JSON AST.
+[![npm](https://img.shields.io/npm/v/@iyulab/m3l)](https://www.npmjs.com/package/@iyulab/m3l)
+[![TypeScript CI](https://github.com/iyulab/m3l/actions/workflows/parser-publish.yml/badge.svg)](https://github.com/iyulab/m3l/actions/workflows/parser-publish.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE)
+
+M3L (Meta Model Markup Language) parser and CLI — parse `.m3l.md` / `.m3l` files into a structured JSON AST.
 
 M3L is a Markdown-based data modeling language. You write data models in readable Markdown, and this parser converts them into a machine-processable AST with full validation.
 
@@ -107,6 +111,7 @@ npx m3l validate ./models --strict --format json
 | `## Name ::enum` | Enum definition |
 | `## Name ::interface` | Interface definition |
 | `## Name ::view` | Derived view |
+| `## @name ::attribute` | Attribute registry entry |
 | `- field: type` | Field definition |
 | `- field: type?` | Nullable field |
 | `- field: type[]` | Array field |
@@ -133,6 +138,7 @@ interface M3LAST {
   enums: EnumNode[];
   interfaces: ModelNode[];
   views: ModelNode[];
+  attributeRegistry: AttributeRegistryEntry[];
   errors: Diagnostic[];
   warnings: Diagnostic[];
 }
@@ -146,10 +152,10 @@ interface FieldNode {
   label?: string;
   type?: string;
   params?: (string | number)[];
-  generic_params?: string[];     // map<K,V> → ["K", "V"]
+  generic_params?: string[];     // map<K,V> -> ["K", "V"]
   nullable: boolean;
   array: boolean;
-  arrayItemNullable: boolean;    // string?[] → true
+  arrayItemNullable: boolean;    // string?[] -> true
   kind: 'stored' | 'computed' | 'lookup' | 'rollup';
   default_value?: string;
   description?: string;
@@ -163,17 +169,61 @@ interface FieldNode {
   loc: SourceLocation;
 }
 
-interface ModelNode {
+interface FieldAttribute {
+  name: string;
+  args?: (string | number | boolean)[];
+  cascade?: string;
+  isStandard?: boolean;          // true for M3L standard attributes
+  isRegistered?: boolean;        // true for attributes in the registry
+}
+
+interface CustomAttribute {
+  content: string;               // e.g. "MaxLength(100)"
+  raw: string;                   // e.g. "[MaxLength(100)]"
+  parsed?: {                     // structured parse result
+    name: string;
+    arguments: (string | number | boolean)[];
+  };
+}
+
+interface AttributeRegistryEntry {
   name: string;
-  type: 'model' | 'enum' | 'interface' | 'view';
-  inherits: string[];
-  attributes: FieldAttribute[];  // model-level attributes (@public, etc.)
-  fields: FieldNode[];
-  sections: { indexes; relations; behaviors; metadata; [key: string]: unknown };
-  // ...
+  description?: string;
+  target: ('field' | 'model')[];
+  type: string;
+  range?: [number, number];
+  required: boolean;
+  defaultValue?: string | number | boolean;
 }
 ```
 
+## Attribute Registry
+
+Define custom attributes with validation metadata using `::attribute`:
+
+```markdown
+## @pii ::attribute
+> Personal identifiable information marker
+- target: [field]
+- type: boolean
+- default: false
+
+## @audit_level ::attribute
+> Audit compliance level
+- target: [field, model]
+- type: integer
+- range: [1, 5]
+- default: 1
+```
+
+Attributes are classified into 3 tiers:
+
+| Tier | `isStandard` | `isRegistered` | Example |
+|------|-------------|----------------|---------|
+| Standard | `true` | — | `@primary`, `@unique`, `@reference` |
+| Registered | — | `true` | `@pii`, `@audit_level` (defined via `::attribute`) |
+| Unregistered | — | — | `@some_unknown_attr` |
+
 ## Validation
 
 The validator checks for semantic errors and style warnings:
@@ -184,7 +234,9 @@ The validator checks for semantic errors and style warnings:
 | M3L-E001 | Rollup FK field missing `@reference` |
 | M3L-E002 | Lookup FK field missing `@reference` |
 | M3L-E004 | View references non-existent model |
+| M3L-E005 | Duplicate model/enum name |
 | M3L-E006 | Duplicate field name within model |
+| M3L-E007 | Unresolved parent in inheritance |
 
 **Warnings (--strict):**
 | Code | Description |
@@ -221,6 +273,10 @@ Parse an M3L content string into an AST.
 
 Parse and validate M3L files. Options: `{ strict?: boolean }`.
 
+### `STANDARD_ATTRIBUTES: Set<string>`
+
+The set of 27 M3L standard attribute names (e.g. `primary`, `unique`, `reference`, `computed`, ...).
+
 ### Lower-level API
 
 ```typescript
@@ -238,7 +294,7 @@ This TypeScript parser and the [C# parser](../csharp/) produce equivalent AST st
 
 | | TypeScript | C# |
 |---|---|---|
-| Package | `@iyulab/m3l` | `Iyulab.M3L` |
+| Package | `@iyulab/m3l` | `M3LParser` |
 | Runtime | Node.js 20+ | .NET 8.0+ |
 | AST Version | 1.0 | 1.0 |
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { lex } from './lexer.js';
-export { parseTokens, parseString as parseFileString } from './parser.js';
+export { parseTokens, parseString as parseFileString, STANDARD_ATTRIBUTES } from './parser.js';
 export { resolve, AST_VERSION, PARSER_VERSION } from './resolver.js';
 export { validate } from './validator.js';
 export { readM3LFiles, readM3LString, readProjectConfig } from './reader.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { lex } from './lexer.js';
-export { parseTokens, parseString as parseFileString } from './parser.js';
+export { parseTokens, parseString as parseFileString, STANDARD_ATTRIBUTES } from './parser.js';
 export { resolve, AST_VERSION, PARSER_VERSION } from './resolver.js';
 export { validate } from './validator.js';
 export { readM3LFiles, readM3LString, readProjectConfig } from './reader.js';
@@ -15,7 +15,7 @@ export async function parse(inputPath) {
     const resolved = resolvePath(inputPath);
     const files = await readM3LFiles(resolved);
     if (files.length === 0) {
-        throw new Error(`No .m3l.md files found at: ${inputPath}`);
+        throw new Error(`No .m3l.md or .m3l files found at: ${inputPath}`);
     }
     const parsedFiles = files.map(f => parseFileContent(f.content, f.path));
     let projectInfo;

package/dist/lexer.js

@@ -3,11 +3,11 @@ const RE_H1 = /^# (.+)$/;
 const RE_H2 = /^## (.+)$/;
 const RE_H3 = /^### (.+)$/;
 const RE_HR = /^-{3,}$/;
-const RE_BLOCKQUOTE = /^> (.+)$/;
+const RE_BLOCKQUOTE = /^\s*> (.+)$/;
 const RE_LIST_ITEM = /^(\s*)- (.+)$/;
 const RE_BLANK = /^\s*$/;
 // H2 sub-patterns
-const RE_TYPE_INDICATOR = /^([\w][\w.]*(?:\([^)]*\))?)\s*::(\w+)(.*)$/;
+const RE_TYPE_INDICATOR = /^(@?[\w][\w.]*(?:\([^)]*\))?)\s*::(\w+)(.*)$/;
 const RE_MODEL_DEF = /^([\w][\w.]*(?:\([^)]*\))?)\s*(?::\s*(.+?))?(\s+@.+)?$/;
 // Field line patterns
 const RE_FIELD_NAME = /^([\w]+)(?:\(([^)]*)\))?\s*(?::\s*(.+))?$/;
@@ -135,7 +135,7 @@ export function lex(content, file) {
     return tokens;
 }
 function tokenizeH2(content, raw, line) {
-    // Check for type indicator: ## Name ::enum, ::interface, ::view
+    // Check for type indicator: ## Name ::enum, ::interface, ::view, ::attribute
     const typeMatch = content.match(RE_TYPE_INDICATOR);
     if (typeMatch) {
         const namepart = typeMatch[1];
@@ -143,6 +143,14 @@ function tokenizeH2(content, raw, line) {
         const rest = typeMatch[3]?.trim() || '';
         const { name, label } = parseNameLabel(namepart);
         const data = { name, label };
+        // Parse inheritance: ::enum : Base1, Base2
+        const inheritMatch = rest.match(/^:\s*(.+?)(?:\s+@|\s*"|\s*$)/);
+        if (inheritMatch) {
+            data.inherits = inheritMatch[1].split(',').map(s => s.trim()).filter(Boolean);
+        }
+        else {
+            data.inherits = [];
+        }
         if (typeIndicator === 'view') {
             data.materialized = rest.includes('@materialized');
         }
@@ -151,7 +159,8 @@ function tokenizeH2(content, raw, line) {
         if (descMatch) {
             data.description = descMatch[1];
         }
-        return { type: typeIndicator, raw, line, indent: 0, data };
+        const tokenType = typeIndicator === 'attribute' ? 'attribute_def' : typeIndicator;
+        return { type: tokenType, raw, line, indent: 0, data };
     }
     // Regular model: ## Name : Parent1, Parent2
     const modelMatch = content.match(RE_MODEL_DEF);

package/dist/parser.d.ts

@@ -1,4 +1,9 @@
 import type { Token, ParsedFile } from './types.js';
+/**
+ * Standard M3L attribute catalog.
+ * These are the officially defined attributes in the M3L specification.
+ */
+export declare const STANDARD_ATTRIBUTES: Set<string>;
 /**
  * Parse M3L content string into a ParsedFile AST.
  */

package/dist/parser.js

@@ -1,4 +1,22 @@
 import { lex, parseTypeAndAttrs } from './lexer.js';
+/**
+ * Standard M3L attribute catalog.
+ * These are the officially defined attributes in the M3L specification.
+ */
+export const STANDARD_ATTRIBUTES = new Set([
+    // Field constraints
+    'primary', 'unique', 'required', 'index', 'generated', 'immutable',
+    // References / relations
+    'reference', 'fk', 'relation', 'on_update', 'on_delete',
+    // Search / display
+    'searchable', 'description', 'visibility',
+    // Validation
+    'min', 'max', 'validate', 'not_null',
+    // Derived fields
+    'computed', 'computed_raw', 'lookup', 'rollup', 'from', 'persisted',
+    // Model-level
+    'public', 'private', 'materialized', 'meta', 'behavior', 'override', 'default_attribute',
+]);
 /**
  * Parse M3L content string into a ParsedFile AST.
  */
@@ -21,6 +39,8 @@ export function parseTokens(tokens, file) {
         enums: [],
         interfaces: [],
         views: [],
+        attributeRegistry: [],
+        currentAttrDef: null,
         sourceDirectivesDone: false,
     };
     for (const token of tokens) {
@@ -35,6 +55,7 @@ export function parseTokens(tokens, file) {
         enums: state.enums,
         interfaces: state.interfaces,
         views: state.views,
+        attributeRegistry: state.attributeRegistry,
     };
 }
 function processToken(token, state) {
@@ -52,6 +73,9 @@ function processToken(token, state) {
         case 'view':
             handleViewStart(token, state);
             break;
+        case 'attribute_def':
+            handleAttributeDefStart(token, state);
+            break;
         case 'section':
             handleSection(token, state);
             break;
@@ -115,6 +139,7 @@ function handleEnumStart(token, state) {
         type: 'enum',
         source: state.file,
         line: token.line,
+        inherits: data.inherits || [],
         description: data.description,
         values: [],
         loc: { file: state.file, line: token.line, col: 1 },
@@ -181,6 +206,18 @@ function handleSection(token, state) {
     }
 }
 function handleField(token, state) {
+    // Handle attribute definition fields (- target: [field, model])
+    if (state.currentAttrDef) {
+        const data = token.data;
+        const name = data.name;
+        const raw = token.raw.trim().replace(/^-\s*/, '');
+        const colonIdx = raw.indexOf(':');
+        if (colonIdx >= 0) {
+            const value = raw.substring(colonIdx + 1).trim();
+            state.currentAttrDef.fields.set(name, value);
+        }
+        return;
+    }
     if (!state.currentElement)
         return;
     const data = token.data;
@@ -229,11 +266,12 @@ function handleDirective(data, model, token, state) {
     if (!attrs || attrs.length === 0)
         return;
     const attr = attrs[0];
-    if (attr.name === 'index') {
+    if (attr.name === 'index' || attr.name === 'unique') {
         model.sections.indexes.push({
             type: 'directive',
             raw: data.raw_content,
             args: attr.args,
+            unique: attr.name === 'unique',
             loc: { file: state.file, line: token.line, col: 1 },
         });
     }
@@ -322,6 +360,7 @@ function handleSectionItem(data, model, token, state) {
             raw: token.raw.trim().replace(/^- /, ''),
             loc,
         });
+        state.lastField = { name: token.raw.trim().replace(/^- /, '') };
         return;
     }
     // Metadata section
@@ -384,6 +423,16 @@ function handleNestedItem(token, state) {
         }
         return;
     }
+    // Nested items under relation in Relations section
+    if (state.currentSection === 'Relations' && state.lastField) {
+        const lastRelation = model.sections.relations[model.sections.relations.length - 1];
+        if (lastRelation && typeof lastRelation === 'object') {
+            if (key) {
+                lastRelation[key] = parseNestedValue(value || '');
+            }
+        }
+        return;
+    }
     // Nested items under a field
     if (state.lastField) {
         const field = state.lastField;
@@ -455,9 +504,25 @@ function handleNestedItem(token, state) {
     }
 }
 function handleBlockquote(token, state) {
+    // Handle attribute definition description
+    if (state.currentAttrDef) {
+        const text = token.data.text;
+        state.currentAttrDef.description = text;
+        return;
+    }
     if (!state.currentElement)
         return;
     const text = token.data.text;
+    // Field-level blockquote: apply to lastField if available (not for enums)
+    if (state.lastField && !isEnumNode(state.currentElement)) {
+        if (state.lastField.description) {
+            state.lastField.description += '\n' + text;
+        }
+        else {
+            state.lastField.description = text;
+        }
+        return;
+    }
     if (state.currentElement.description) {
         state.currentElement.description += '\n' + text;
     }
@@ -478,6 +543,8 @@ function handleText(token, state) {
     }
 }
 function finalizeElement(state) {
+    // Finalize pending attribute definition
+    finalizeAttrDef(state);
     if (!state.currentElement)
         return;
     if (isEnumNode(state.currentElement)) {
@@ -502,6 +569,70 @@ function finalizeElement(state) {
     state.currentKind = 'stored';
     state.lastField = null;
 }
+function handleAttributeDefStart(token, state) {
+    finalizeElement(state);
+    const data = token.data || {};
+    const name = (data.name || '').replace(/^@/, '');
+    state.currentAttrDef = {
+        name,
+        description: data.description,
+        fields: new Map(),
+    };
+    state.currentElement = null;
+}
+function finalizeAttrDef(state) {
+    if (!state.currentAttrDef)
+        return;
+    const def = state.currentAttrDef;
+    const fields = def.fields;
+    const targetRaw = fields.get('target');
+    const target = [];
+    if (targetRaw) {
+        const cleaned = targetRaw.replace(/^\[|\]$/g, '').split(',').map(s => s.trim());
+        for (const t of cleaned) {
+            if (t === 'field' || t === 'model')
+                target.push(t);
+        }
+    }
+    const rangeRaw = fields.get('range');
+    let range;
+    if (rangeRaw) {
+        const nums = rangeRaw.replace(/^\[|\]$/g, '').split(',').map(s => Number(s.trim()));
+        if (nums.length === 2 && !isNaN(nums[0]) && !isNaN(nums[1])) {
+            range = [nums[0], nums[1]];
+        }
+    }
+    const requiredRaw = fields.get('required');
+    const required = requiredRaw === 'true' || requiredRaw === true;
+    const defaultRaw = fields.get('default');
+    let defaultValue;
+    if (defaultRaw !== undefined) {
+        if (defaultRaw === 'true')
+            defaultValue = true;
+        else if (defaultRaw === 'false')
+            defaultValue = false;
+        else if (typeof defaultRaw === 'string' && !isNaN(Number(defaultRaw)))
+            defaultValue = Number(defaultRaw);
+        else if (typeof defaultRaw === 'string')
+            defaultValue = defaultRaw;
+        else if (typeof defaultRaw === 'number' || typeof defaultRaw === 'boolean')
+            defaultValue = defaultRaw;
+    }
+    const entry = {
+        name: def.name,
+        target: target.length > 0 ? target : ['field'],
+        type: fields.get('type') || 'boolean',
+        required,
+    };
+    if (def.description)
+        entry.description = def.description;
+    if (range)
+        entry.range = range;
+    if (defaultValue !== undefined)
+        entry.defaultValue = defaultValue;
+    state.attributeRegistry.push(entry);
+    state.currentAttrDef = null;
+}
 // --- Helpers ---
 function buildFieldNode(data, token, state) {
     const attrs = parseAttributes(data.attributes);
@@ -559,6 +690,10 @@ function buildFieldNode(data, token, state) {
             field.computed.platform = parts.platform;
         }
     }
+    // Inline comment as field description
+    if (!field.description && data.comment) {
+        field.description = data.comment;
+    }
     return field;
 }
 /**
@@ -602,6 +737,8 @@ function parseAttributes(rawAttrs) {
             attr.args = [a.args];
         if (a.cascade)
             attr.cascade = a.cascade;
+        if (STANDARD_ATTRIBUTES.has(a.name))
+            attr.isStandard = true;
         return attr;
     });
 }
@@ -798,9 +935,57 @@ function parseCustomAttributes(rawAttrs) {
     return rawAttrs.map(raw => {
         // raw is "[MaxLength(100)]" — strip brackets to get content
         const content = raw.replace(/^\[|\]$/g, '');
-        return { content, raw };
+        const attr = { content, raw };
+        // Try to parse "Name(arg1, arg2)" or "Name" pattern
+        const match = content.match(/^([A-Za-z_][\w.]*)(?:\((.+)\))?$/);
+        if (match) {
+            const name = match[1];
+            const argsStr = match[2];
+            const args = [];
+            if (argsStr) {
+                for (const part of splitBalanced(argsStr)) {
+                    const trimmed = part.trim();
+                    args.push(parseArgValue(trimmed));
+                }
+            }
+            attr.parsed = { name, arguments: args };
+        }
+        return attr;
     });
 }
+/** Split a string by commas, respecting balanced parentheses */
+function splitBalanced(s) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '(')
+            depth++;
+        else if (s[i] === ')')
+            depth--;
+        else if (s[i] === ',' && depth === 0) {
+            parts.push(s.substring(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(s.substring(start));
+    return parts;
+}
+/** Parse a single argument value: numbers, booleans, or strings */
+function parseArgValue(s) {
+    if (s === 'true')
+        return true;
+    if (s === 'false')
+        return false;
+    const n = Number(s);
+    if (!isNaN(n) && s.length > 0)
+        return n;
+    // Strip surrounding quotes if present
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
 function isEnumNode(el) {
     return el.type === 'enum' && 'values' in el;
 }

package/dist/reader.d.ts

@@ -4,7 +4,7 @@ export interface M3LFile {
 }
 /**
  * Read M3L files from a path (file or directory).
- * If path is a directory, scans for **\/*.m3l.md files.
+ * If path is a directory, scans for **\/*.m3l.md and **\/*.m3l files.
  * If an m3l.config.yaml exists in the directory, uses its sources patterns.
  */
 export declare function readM3LFiles(inputPath: string): Promise<M3LFile[]>;

package/dist/reader.js

@@ -3,7 +3,7 @@ import { join, resolve as resolvePath } from 'path';
 import fg from 'fast-glob';
 /**
  * Read M3L files from a path (file or directory).
- * If path is a directory, scans for **\/*.m3l.md files.
+ * If path is a directory, scans for **\/*.m3l.md and **\/*.m3l files.
  * If an m3l.config.yaml exists in the directory, uses its sources patterns.
  */
 export async function readM3LFiles(inputPath) {

package/dist/resolver.d.ts

@@ -2,7 +2,7 @@ import type { ParsedFile, M3LAST, ProjectInfo } from './types.js';
 /** AST schema version — bump major on breaking structure changes */
 export declare const AST_VERSION = "1.0";
 /** Parser package version — kept in sync with package.json */
-export declare const PARSER_VERSION = "0.1.2";
+export declare const PARSER_VERSION = "0.1.4";
 /**
  * Resolve and merge multiple parsed file ASTs into a single M3LAST.
  * Handles: inheritance resolution, duplicate detection, reference validation.

package/dist/resolver.js

@@ -1,7 +1,7 @@
 /** AST schema version — bump major on breaking structure changes */
 export const AST_VERSION = '1.0';
 /** Parser package version — kept in sync with package.json */
-export const PARSER_VERSION = '0.1.2';
+export const PARSER_VERSION = '0.1.4';
 /**
  * Resolve and merge multiple parsed file ASTs into a single M3LAST.
  * Handles: inheritance resolution, duplicate detection, reference validation.
@@ -14,6 +14,7 @@ export function resolve(files, project) {
     const allEnums = [];
     const allInterfaces = [];
     const allViews = [];
+    const allAttrRegistry = [];
     const sources = [];
     for (const file of files) {
         sources.push(file.source);
@@ -21,6 +22,8 @@ export function resolve(files, project) {
         allEnums.push(...file.enums);
         allInterfaces.push(...file.interfaces);
         allViews.push(...file.views);
+        if (file.attributeRegistry)
+            allAttrRegistry.push(...file.attributeRegistry);
     }
     // Build name maps
     const modelMap = new Map();
@@ -54,6 +57,29 @@ export function resolve(files, project) {
     for (const model of [...allModels, ...allViews]) {
         checkDuplicateFields(model, errors);
     }
+    // Tag isRegistered on attributes matching the registry
+    if (allAttrRegistry.length > 0) {
+        const registeredNames = new Set(allAttrRegistry.map(r => r.name));
+        const tagAttrs = (attrs) => {
+            for (const a of attrs) {
+                if (registeredNames.has(a.name)) {
+                    a.isRegistered = true;
+                }
+            }
+        };
+        const tagModel = (m) => {
+            tagAttrs(m.attributes);
+            for (const f of m.fields) {
+                tagAttrs(f.attributes);
+            }
+        };
+        for (const m of allModels)
+            tagModel(m);
+        for (const v of allViews)
+            tagModel(v);
+        for (const i of allInterfaces)
+            tagModel(i);
+    }
     // Detect namespace from first file if available
     const projectInfo = project || {};
     if (!projectInfo.name) {
@@ -70,6 +96,7 @@ export function resolve(files, project) {
         enums: allEnums,
         interfaces: allInterfaces,
         views: allViews,
+        attributeRegistry: allAttrRegistry,
         errors,
         warnings,
     };

package/dist/types.d.ts

@@ -4,7 +4,7 @@ export interface SourceLocation {
     line: number;
     col: number;
 }
-export type TokenType = 'namespace' | 'model' | 'enum' | 'interface' | 'view' | 'section' | 'field' | 'nested_item' | 'blockquote' | 'horizontal_rule' | 'blank' | 'text';
+export type TokenType = 'namespace' | 'model' | 'enum' | 'interface' | 'view' | 'attribute_def' | 'section' | 'field' | 'nested_item' | 'blockquote' | 'horizontal_rule' | 'blank' | 'text';
 export interface Token {
     type: TokenType;
     raw: string;
@@ -17,6 +17,10 @@ export interface FieldAttribute {
     name: string;
     args?: (string | number | boolean)[];
     cascade?: string;
+    /** Whether this is a standard M3L attribute (from the official catalog) */
+    isStandard?: boolean;
+    /** Whether this attribute is registered in an Attribute Registry (::attribute definition) */
+    isRegistered?: boolean;
 }
 /** Structured representation of a backtick-wrapped framework attribute like `[MaxLength(100)]` */
 export interface CustomAttribute {
@@ -24,6 +28,11 @@ export interface CustomAttribute {
     content: string;
     /** Original text including brackets, e.g., "[MaxLength(100)]" */
     raw: string;
+    /** Parsed structure — name and arguments extracted from the content */
+    parsed?: {
+        name: string;
+        arguments: (string | number | boolean)[];
+    };
 }
 export interface EnumValue {
     name: string;
@@ -104,6 +113,7 @@ export interface EnumNode {
     type: 'enum';
     source: string;
     line: number;
+    inherits: string[];
     description?: string;
     values: EnumValue[];
     loc: SourceLocation;
@@ -127,6 +137,23 @@ export interface ParsedFile {
     enums: EnumNode[];
     interfaces: ModelNode[];
     views: ModelNode[];
+    attributeRegistry: AttributeRegistryEntry[];
+}
+export interface AttributeRegistryEntry {
+    /** Attribute name (without @) */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Valid targets: 'field', 'model' */
+    target: ('field' | 'model')[];
+    /** Value type: 'boolean', 'integer', 'string', etc. */
+    type: string;
+    /** Valid range for numeric types */
+    range?: [number, number];
+    /** Whether the attribute is required */
+    required: boolean;
+    /** Default value */
+    defaultValue?: string | number | boolean;
 }
 export interface M3LAST {
     /** Parser package version (semver) */
@@ -139,6 +166,8 @@ export interface M3LAST {
     enums: EnumNode[];
     interfaces: ModelNode[];
     views: ModelNode[];
+    /** Attribute registry entries parsed from ::attribute definitions */
+    attributeRegistry: AttributeRegistryEntry[];
     errors: Diagnostic[];
     warnings: Diagnostic[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iyulab/m3l",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "M3L parser and CLI tool — parse .m3l.md files into JSON AST",
   "type": "module",
   "main": "dist/index.js",