@iyulab/m3l 0.1.1 → 0.1.3

package/README.md

@@ -64,7 +64,7 @@ npx m3l validate ./models --strict --format json
 - bio(Biography): text?
 - birth_date: date?
 
-# Rollup
+### Rollup
 - book_count: integer @rollup(BookAuthor.author_id, count)
 
 > Stores information about book authors.
@@ -82,10 +82,10 @@ npx m3l validate ./models --strict --format json
   - borrowed: "Borrowed"
 - publisher_id: identifier @fk(Publisher.id)
 
-# Lookup
+### Lookup
 - publisher_name: string @lookup(publisher_id.name)
 
-# Computed
+### Computed
 - is_available: boolean @computed("status = 'available' AND quantity > 0")
 
 ## OverdueLoans ::view @materialized
@@ -110,9 +110,11 @@ npx m3l validate ./models --strict --format json
 | `- field: type` | Field definition |
 | `- field: type?` | Nullable field |
 | `- field: type[]` | Array field |
+| `- field: type?[]` | Array of nullable items |
 | `- field: type = val` | Field with default value |
 | `@attr` / `@attr(args)` | Attribute (constraint, index, etc.) |
-| `# Lookup` / `# Rollup` / `# Computed` | Kind section for derived fields |
+| `` `[FrameworkAttr]` `` | Custom framework attribute |
+| `### Lookup` / `### Rollup` / `### Computed` | Kind section for derived fields |
 | `### Section` | Named section (Indexes, Relations, Metadata, etc.) |
 | `> text` | Model/element description |
 | `"text"` | Inline description on field |
@@ -123,18 +125,54 @@ The parser produces an `M3LAST` object:
 
 ```typescript
 interface M3LAST {
+  parserVersion: string;   // Parser package version (semver)
+  astVersion: string;      // AST schema version
   project: { name?: string; version?: string };
-  sources: string[];         // parsed file paths
-  models: ModelNode[];       // models and interfaces
-  enums: EnumNode[];         // enum definitions
-  interfaces: ModelNode[];   // interface definitions
-  views: ModelNode[];        // derived views
-  errors: Diagnostic[];      // parse/resolve errors
-  warnings: Diagnostic[];    // validation warnings
+  sources: string[];
+  models: ModelNode[];
+  enums: EnumNode[];
+  interfaces: ModelNode[];
+  views: ModelNode[];
+  errors: Diagnostic[];
+  warnings: Diagnostic[];
 }
 ```
 
-Each `ModelNode` contains fields, sections (indexes, relations, metadata), inheritance info, and source locations for error reporting.
+### Key AST types
+
+```typescript
+interface FieldNode {
+  name: string;
+  label?: string;
+  type?: string;
+  params?: (string | number)[];
+  generic_params?: string[];     // map<K,V> → ["K", "V"]
+  nullable: boolean;
+  array: boolean;
+  arrayItemNullable: boolean;    // string?[] → true
+  kind: 'stored' | 'computed' | 'lookup' | 'rollup';
+  default_value?: string;
+  description?: string;
+  attributes: FieldAttribute[];
+  framework_attrs?: CustomAttribute[];
+  lookup?: { path: string };
+  rollup?: { target: string; fk: string; aggregate: string; field?: string; where?: string };
+  computed?: { expression: string };
+  enum_values?: EnumValue[];
+  fields?: FieldNode[];          // sub-fields for object type
+  loc: SourceLocation;
+}
+
+interface ModelNode {
+  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 };
+  // ...
+}
+```
 
 ## Validation
 
@@ -143,20 +181,17 @@ The validator checks for semantic errors and style warnings:
 **Errors:**
 | Code | Description |
 |------|-------------|
-| E001 | Rollup FK field missing `@reference` |
-| E002 | Lookup FK field missing `@reference` |
-| E004 | View references non-existent model |
-| E005 | Duplicate model/enum name |
-| E006 | Duplicate field name within model |
-| E007 | Unresolved parent in inheritance |
+| M3L-E001 | Rollup FK field missing `@reference` |
+| M3L-E002 | Lookup FK field missing `@reference` |
+| M3L-E004 | View references non-existent model |
+| M3L-E006 | Duplicate field name within model |
 
 **Warnings (--strict):**
 | Code | Description |
 |------|-------------|
-| W001 | Model has no fields |
-| W002 | Model has no description |
-| W003 | Field missing label |
-| W004 | Enum has no values |
+| M3L-W001 | Field line exceeds 80 characters |
+| M3L-W002 | Object nesting exceeds 3 levels |
+| M3L-W004 | Lookup chain exceeds 3 hops |
 
 ## Multi-file Projects
 
@@ -197,6 +232,18 @@ const ast = resolve([parsed]);
 const diagnostics = validate(ast, { strict: true });
 ```
 
+## Compatibility
+
+This TypeScript parser and the [C# parser](../csharp/) produce equivalent AST structures. Both share the same conformance test suite.
+
+| | TypeScript | C# |
+|---|---|---|
+| Package | `@iyulab/m3l` | `M3LParser` |
+| Runtime | Node.js 20+ | .NET 8.0+ |
+| AST Version | 1.0 | 1.0 |
+
+Version is managed centrally via the root `VERSION` file.
+
 ## License
 
 MIT

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

@@ -7,7 +7,7 @@ const RE_BLOCKQUOTE = /^> (.+)$/;
 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*(.+))?$/;
@@ -35,15 +35,20 @@ export function lex(content, file) {
             tokens.push({ type: 'horizontal_rule', raw, line: lineNum, indent: 0 });
             continue;
         }
-        // H3 — Section header
+        // H3 — Section header (including kind sections: ### Lookup, ### Rollup, ### Computed)
         const h3Match = raw.match(RE_H3);
         if (h3Match) {
+            const h3Name = h3Match[1].trim();
+            const data = { name: h3Name };
+            if (KIND_SECTIONS.has(h3Name)) {
+                data.kind_section = true;
+            }
             tokens.push({
                 type: 'section',
                 raw,
                 line: lineNum,
                 indent: 0,
-                data: { name: h3Match[1].trim() },
+                data,
             });
             continue;
         }
@@ -54,29 +59,17 @@ export function lex(content, file) {
             tokens.push(tokenizeH2(h2Content, raw, lineNum));
             continue;
         }
-        // H1 — Namespace or kind-section context
+        // H1 — Namespace / Document title only
         const h1Match = raw.match(RE_H1);
         if (h1Match) {
             const h1Content = h1Match[1].trim();
-            // Check if this is a kind section (# Lookup, # Rollup, # Computed)
-            if (KIND_SECTIONS.has(h1Content)) {
-                tokens.push({
-                    type: 'section',
-                    raw,
-                    line: lineNum,
-                    indent: 0,
-                    data: { name: h1Content, kind_section: true },
-                });
-            }
-            else {
-                tokens.push({
-                    type: 'namespace',
-                    raw,
-                    line: lineNum,
-                    indent: 0,
-                    data: parseNamespace(h1Content),
-                });
-            }
+            tokens.push({
+                type: 'namespace',
+                raw,
+                line: lineNum,
+                indent: 0,
+                data: parseNamespace(h1Content),
+            });
             continue;
         }
         // Blockquote
@@ -142,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];
@@ -158,7 +151,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);
@@ -331,9 +325,24 @@ export function parseTypeAndAttrs(rest, data) {
             skipWS();
         }
     }
-    // Parse attributes: @name or @name(balanced_args)
+    // Parse attributes: @name or @name(balanced_args), with optional cascade symbols (! !!)
     const attrs = [];
-    while (pos < len && rest[pos] === '@') {
+    while (pos < len && (rest[pos] === '@' || rest[pos] === '!' || rest[pos] === '?')) {
+        // Cascade symbols: !, !!, ? — attach to the previous attribute
+        if (rest[pos] === '!' || rest[pos] === '?') {
+            let symbol = rest[pos];
+            pos++;
+            if (symbol === '!' && pos < len && rest[pos] === '!') {
+                symbol = '!!';
+                pos++;
+            }
+            // Attach cascade to last attribute
+            if (attrs.length > 0) {
+                attrs[attrs.length - 1].cascade = symbol;
+            }
+            skipWS();
+            continue;
+        }
         pos++; // skip @
         const nameStart = pos;
         while (pos < len && /\w/.test(rest[pos]))

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;
@@ -75,11 +99,6 @@ function processToken(token, state) {
 }
 function handleNamespace(token, state) {
     const data = token.data;
-    // Check if this is a kind section (# Lookup, # Rollup, etc.)
-    if (data.kind_section) {
-        handleSection(token, state);
-        return;
-    }
     if (!state.currentElement) {
         state.namespace = data.name;
     }
@@ -186,6 +205,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;
@@ -460,6 +491,12 @@ 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;
@@ -483,6 +520,8 @@ function handleText(token, state) {
     }
 }
 function finalizeElement(state) {
+    // Finalize pending attribute definition
+    finalizeAttrDef(state);
     if (!state.currentElement)
         return;
     if (isEnumNode(state.currentElement)) {
@@ -507,6 +546,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);
@@ -554,20 +657,63 @@ function buildFieldNode(data, token, state) {
         const expr = computedAttr.args[0].replace(/^["']|["']$/g, '');
         field.computed = { expression: expr };
     }
-    // Parse computed_raw: @computed_raw("expression", ...)
+    // Parse computed_raw: @computed_raw("expression", platform: "name")
     if (computedRawAttr && computedRawAttr.args?.[0]) {
-        const expr = computedRawAttr.args[0].replace(/^["']|["']$/g, '');
+        const rawArgs = computedRawAttr.args[0];
+        const parts = splitComputedRawArgs(rawArgs);
+        const expr = parts.expression.replace(/^["']|["']$/g, '');
         field.computed = { expression: expr };
+        if (parts.platform) {
+            field.computed.platform = parts.platform;
+        }
     }
     return field;
 }
+/**
+ * Split @computed_raw args: "expr", platform: "name"
+ * Returns the expression (first positional arg) and optional named params.
+ */
+function splitComputedRawArgs(raw) {
+    // Find the first quoted string as the expression
+    const quoteChar = raw[0];
+    if (quoteChar === '"' || quoteChar === "'") {
+        // Find matching closing quote (not escaped)
+        let i = 1;
+        while (i < raw.length) {
+            if (raw[i] === '\\') {
+                i += 2;
+                continue;
+            }
+            if (raw[i] === quoteChar)
+                break;
+            i++;
+        }
+        const expression = raw.slice(0, i + 1); // includes quotes
+        const remainder = raw.slice(i + 1).trim();
+        // Parse named params from remainder: , platform: "sqlserver"
+        let platform;
+        const platformMatch = remainder.match(/platform\s*:\s*["']([^"']+)["']/);
+        if (platformMatch) {
+            platform = platformMatch[1];
+        }
+        return { expression, platform };
+    }
+    // No quotes — treat entire string as expression
+    return { expression: raw };
+}
 function parseAttributes(rawAttrs) {
     if (!rawAttrs)
         return [];
-    return rawAttrs.map(a => ({
-        name: a.name,
-        args: a.args ? [a.args] : undefined,
-    }));
+    return rawAttrs.map(a => {
+        const attr = { name: a.name };
+        if (a.args)
+            attr.args = [a.args];
+        if (a.cascade)
+            attr.cascade = a.cascade;
+        if (STANDARD_ATTRIBUTES.has(a.name))
+            attr.isStandard = true;
+        return attr;
+    });
 }
 function parseTypeParams(params) {
     if (!params)
@@ -697,8 +843,12 @@ function parseMetadataValue(value) {
     if (typeof value !== 'string')
         return value;
     const str = value;
-    // Remove surrounding quotes
+    // If explicitly quoted, preserve as string (don't coerce "1.0" to number)
+    const wasQuoted = (str.startsWith('"') && str.endsWith('"')) ||
+        (str.startsWith("'") && str.endsWith("'"));
     const unquoted = str.replace(/^["']|["']$/g, '');
+    if (wasQuoted)
+        return unquoted;
     // Try number
     const n = Number(unquoted);
     if (!isNaN(n) && unquoted !== '')
@@ -758,9 +908,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.1";
+export declare const PARSER_VERSION = "0.1.3";
 /**
  * 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.1';
+export const PARSER_VERSION = '0.1.3';
 /**
  * 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,
     };
@@ -131,11 +158,10 @@ function resolveInheritance(model, modelMap, interfaceMap, allNamedMap, errors)
     // Handle @override: child fields with @override replace inherited fields
     const overrideNames = new Set();
     for (const ownField of model.fields) {
-        const overrideIdx = ownField.attributes.findIndex(a => a.name === 'override');
-        if (overrideIdx >= 0) {
+        const hasOverride = ownField.attributes.some(a => a.name === 'override');
+        if (hasOverride) {
             overrideNames.add(ownField.name);
-            // Remove @override attribute from the child field
-            ownField.attributes.splice(overrideIdx, 1);
+            // Preserve @override in attributes so AST consumers can detect it
         }
     }
     // Remove inherited fields that are overridden

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;
@@ -16,6 +16,11 @@ export type FieldKind = 'stored' | 'computed' | 'lookup' | 'rollup';
 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 {
@@ -23,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;
@@ -56,6 +66,7 @@ export interface FieldNode {
     };
     computed?: {
         expression: string;
+        platform?: string;
     };
     enum_values?: EnumValue[];
     fields?: FieldNode[];
@@ -125,6 +136,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) */
@@ -137,6 +165,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.1",
+  "version": "0.1.3",
   "description": "M3L parser and CLI tool — parse .m3l.md files into JSON AST",
   "type": "module",
   "main": "dist/index.js",