@rcrsr/rill 0.15.0 → 0.17.0

package/dist/generated/version-data.d.ts

@@ -10,9 +10,8 @@ export interface VersionInfo {
 /**
  * Version string from package.json
  */
-export declare const VERSION = "0.15.0";
+export declare const VERSION = "0.17.0";
 /**
  * Parsed version components
  */
 export declare const VERSION_INFO: VersionInfo;
-//# sourceMappingURL=version-data.d.ts.map

package/dist/generated/version-data.js

@@ -3,14 +3,13 @@
 /**
  * Version string from package.json
  */
-export const VERSION = '0.15.0';
+export const VERSION = '0.17.0';
 /**
  * Parsed version components
  */
 export const VERSION_INFO = {
     major: 0,
-    minor: 15,
+    minor: 17,
     patch: 0,
     prerelease: undefined,
 };
-//# sourceMappingURL=version-data.js.map

package/dist/highlight-map.d.ts

@@ -1,4 +1,3 @@
 import type { TokenType } from './types.js';
 export type HighlightCategory = 'keyword' | 'operator' | 'string' | 'number' | 'bool' | 'comment' | 'variableName' | 'punctuation' | 'bracket' | 'meta';
 export declare const TOKEN_HIGHLIGHT_MAP: ReadonlyMap<TokenType, HighlightCategory>;
-//# sourceMappingURL=highlight-map.d.ts.map

package/dist/highlight-map.js

@@ -75,4 +75,3 @@ export const TOKEN_HIGHLIGHT_MAP = new Map([
     ['FRONTMATTER_DELIM', 'meta'],
     // Intentionally unmapped: NEWLINE, EOF
 ]);
-//# sourceMappingURL=highlight-map.js.map

package/dist/index.d.ts

@@ -5,12 +5,22 @@
 export { LexerError, tokenize, type TokenizeOptions } from './lexer/index.js';
 export { parse, parseWithRecovery } from './parser/index.js';
 export type { ParseResult, RecoveryErrorNode, ErrorNode } from './types.js';
-export { anyTypeValue, type ApplicationCallable, BreakSignal, callable, type CallableFn, type CallFrame, type CaptureEvent, type ConfigFieldDescriptor, createRuntimeContext, createStepper, createTuple, createVector, type DocumentationCoverageResult, emitExtensionEvent, contextResolver, extResolver, type ErrorEvent, execute, type ExecutionResult, type ExecutionStepper, type ExtensionConfigSchema, type ExtensionEvent, type ExtensionFactory, type ExtensionManifest, type ExtensionResult, type FsExtensionContract, type FunctionMetadata, hoistExtension, type HoistedExtension, type HostCallEvent, type FunctionReturnEvent, getCallStack, generateManifest, getDocumentationCoverage, getFunctions, getLanguageReference, buildFieldDescriptor, buildTypeMethodDicts, formatStructuralType, inferElementType, inferStructuralType, inferType, invokeCallable, isApplicationCallable, moduleResolver, isTuple, isCallable, isDict, isFieldTypeWithDefault, isReservedMethod, isRillIterator, isRuntimeCallable, isScriptCallable, isTypeValue, isVector, type KvExtensionContract, type NativeArray, type NativePlainObject, type NativeResult, type NativeValue, type LlmExtensionContract, type SchemaEntry, type ObservabilityCallbacks, type ParamMetadata, popCallFrame, prefixFunctions, pushCallFrame, RESERVED_DICT_METHODS, rillTypeToTypeValue, ReturnSignal, type RillCallable, type RillFieldType, type RillFunction, type RillParam, type RillIterator, type RillTuple, type RillType, type RillTypeValue, type RillValue, type RillVector, type RuntimeCallable, type ResolverResult, type RuntimeCallbacks, type RuntimeContext, type RuntimeOptions, type SchemeResolver, type ScriptCallable, type StepEndEvent, type StepResult, type StepStartEvent, type VectorExtensionContract, structuralTypeEquals, structuralTypeMatches, toNative, VERSION, VERSION_INFO, type VersionInfo, } from './runtime/index.js';
-/** @deprecated Use RillType instead. Will be removed in the next major version. */
-export type { RillStructuralType } from './runtime/index.js';
+export { anyTypeValue, type ApplicationCallable, BreakSignal, buildFieldDescriptor, callable, type CallableFn, type CallFrame, commonType, type CaptureEvent, type ConfigFieldDescriptor, contextResolver, createRuntimeContext, createStepper, createTestContext, createTuple, createVector, type DocumentationCoverageResult, emitExtensionEvent, type ErrorEvent, execute, type ExecutionResult, type ExecutionStepper, ExtensionBindingError, type ExtensionConfigSchema, type ExtensionEvent, type ExtensionFactory, type ExtensionFactoryResult, type ExtensionManifest, extResolver, formatStructure, type FsExtensionContract, type FunctionMetadata, type FunctionReturnEvent, generateManifest, getCallStack, getDocumentationCoverage, getFunctions, getLanguageReference, type HostCallEvent, inferElementType, inferStructure, inferType, invokeCallable, isApplicationCallable, isCallable, isDict, isIterator, isReservedMethod, isRuntimeCallable, isScriptCallable, isTuple, isTypeValue, isVector, type KvExtensionContract, moduleResolver, type NativeArray, type NativePlainObject, type NativeResult, type NativeValue, type ObservabilityCallbacks, type ParamMetadata, paramToFieldDef, popCallFrame, pushCallFrame, RESERVED_DICT_METHODS, type ResolverResult, ReturnSignal, type RillCallable, type RillFieldDef, type RillFunction, type RillIterator, type RillParam, type RillTuple, type RillTypeValue, type RillValue, type RillVector, type RuntimeCallable, type RuntimeCallbacks, type RuntimeContext, type RuntimeOptions, type SchemaEntry, type SchemeResolver, type ScriptCallable, type StepEndEvent, type StepResult, type StepStartEvent, structureEquals, structureMatches, structureToTypeValue, toCallable, toNative, type TypeDefinition, type TypeProtocol, type TypeStructure, VERSION, VERSION_INFO, type VersionInfo, } from './runtime/index.js';
+/** @deprecated Use TypeStructure instead. Will be removed in the next major version. */
+export type { RillType } from './runtime/index.js';
+/** @deprecated Use formatStructure instead. */
+export { formatStructuralType } from './runtime/index.js';
+/** @deprecated Use inferStructure instead. */
+export { inferStructuralType } from './runtime/index.js';
+/** @deprecated Use isIterator instead. */
+export { isRillIterator } from './runtime/index.js';
+/** @deprecated Use structureToTypeValue instead. */
+export { rillTypeToTypeValue } from './runtime/index.js';
+/** @deprecated Use structureEquals instead. */
+export { structuralTypeEquals } from './runtime/index.js';
+/** @deprecated Use structureMatches instead. */
+export { structuralTypeMatches } from './runtime/index.js';
 export { type ErrorCategory, type ErrorDefinition, type ErrorSeverity, ERROR_REGISTRY, renderMessage, getHelpUrl, createError, } from './types.js';
 export { formatRillError, formatRillErrorJson, type FormatErrorOptions, type FormatErrorJsonOptions, type SourceMap, } from './error-formatter.js';
-export { VALID_TYPE_NAMES } from './constants.js';
 export { type HighlightCategory, TOKEN_HIGHLIGHT_MAP, } from './highlight-map.js';
 export * from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,7 +4,20 @@
  */
 export { LexerError, tokenize } from './lexer/index.js';
 export { parse, parseWithRecovery } from './parser/index.js';
-export { anyTypeValue, BreakSignal, callable, createRuntimeContext, createStepper, createTuple, createVector, emitExtensionEvent, contextResolver, extResolver, execute, hoistExtension, getCallStack, generateManifest, getDocumentationCoverage, getFunctions, getLanguageReference, buildFieldDescriptor, buildTypeMethodDicts, formatStructuralType, inferElementType, inferStructuralType, inferType, invokeCallable, isApplicationCallable, moduleResolver, isTuple, isCallable, isDict, isFieldTypeWithDefault, isReservedMethod, isRillIterator, isRuntimeCallable, isScriptCallable, isTypeValue, isVector, popCallFrame, prefixFunctions, pushCallFrame, RESERVED_DICT_METHODS, rillTypeToTypeValue, ReturnSignal, structuralTypeEquals, structuralTypeMatches, toNative, VERSION, VERSION_INFO, } from './runtime/index.js';
+export { anyTypeValue, BreakSignal, buildFieldDescriptor, callable, commonType, contextResolver, createRuntimeContext, createStepper, createTestContext, createTuple, createVector, emitExtensionEvent, execute, ExtensionBindingError, extResolver, formatStructure, generateManifest, getCallStack, getDocumentationCoverage, getFunctions, getLanguageReference, inferElementType, inferStructure, inferType, invokeCallable, isApplicationCallable, isCallable, isDict, isIterator, isReservedMethod, isRuntimeCallable, isScriptCallable, isTuple, isTypeValue, isVector, moduleResolver, paramToFieldDef, popCallFrame, pushCallFrame, RESERVED_DICT_METHODS, ReturnSignal, structureEquals, structureMatches, structureToTypeValue, toCallable, toNative, VERSION, VERSION_INFO, } from './runtime/index.js';
+// Deprecated aliases — old names kept for one release
+/** @deprecated Use formatStructure instead. */
+export { formatStructuralType } from './runtime/index.js';
+/** @deprecated Use inferStructure instead. */
+export { inferStructuralType } from './runtime/index.js';
+/** @deprecated Use isIterator instead. */
+export { isRillIterator } from './runtime/index.js';
+/** @deprecated Use structureToTypeValue instead. */
+export { rillTypeToTypeValue } from './runtime/index.js';
+/** @deprecated Use structureEquals instead. */
+export { structuralTypeEquals } from './runtime/index.js';
+/** @deprecated Use structureMatches instead. */
+export { structuralTypeMatches } from './runtime/index.js';
 // ============================================================
 // ERROR TAXONOMY
 // ============================================================
@@ -14,12 +27,7 @@ export { ERROR_REGISTRY, renderMessage, getHelpUrl, createError, } from './types
 // ============================================================
 export { formatRillError, formatRillErrorJson, } from './error-formatter.js';
 // ============================================================
-// CONSTANTS
-// ============================================================
-export { VALID_TYPE_NAMES } from './constants.js';
-// ============================================================
 // SYNTAX HIGHLIGHTING
 // ============================================================
 export { TOKEN_HIGHLIGHT_MAP, } from './highlight-map.js';
 export * from './types.js';
-//# sourceMappingURL=index.js.map

package/dist/lexer/errors.d.ts

@@ -7,4 +7,3 @@ export declare class LexerError extends RillError {
     readonly location: SourceLocation;
     constructor(errorId: string, message: string, location: SourceLocation, context?: Record<string, unknown>);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/lexer/errors.js

@@ -30,4 +30,3 @@ export class LexerError extends RillError {
         this.location = location;
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/lexer/helpers.d.ts

@@ -11,4 +11,3 @@ export declare function isWhitespace(ch: string): boolean;
 export declare function makeToken(type: TokenType, value: string, start: SourceLocation, end: SourceLocation): Token;
 /** Advance n times and return a token */
 export declare function advanceAndMakeToken(state: LexerState, n: number, type: TokenType, value: string, start: SourceLocation): Token;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/lexer/helpers.js

@@ -27,4 +27,3 @@ export function advanceAndMakeToken(state, n, type, value, start) {
         advance(state);
     return makeToken(type, value, start, currentLocation(state));
 }
-//# sourceMappingURL=helpers.js.map

package/dist/lexer/index.d.ts

@@ -5,4 +5,3 @@
 export { LexerError } from './errors.js';
 export { createLexerState, type LexerState } from './state.js';
 export { nextToken, tokenize, type TokenizeOptions } from './tokenizer.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/lexer/index.js

@@ -5,4 +5,3 @@
 export { LexerError } from './errors.js';
 export { createLexerState } from './state.js';
 export { nextToken, tokenize } from './tokenizer.js';
-//# sourceMappingURL=index.js.map

package/dist/lexer/operators.d.ts

@@ -8,4 +8,3 @@ export declare const TWO_CHAR_OPERATORS: Record<string, TokenType>;
 export declare const SINGLE_CHAR_OPERATORS: Record<string, TokenType>;
 /** Keyword lookup table */
 export declare const KEYWORDS: Record<string, TokenType>;
-//# sourceMappingURL=operators.d.ts.map

package/dist/lexer/operators.js

@@ -56,4 +56,3 @@ export const KEYWORDS = {
     fold: TOKEN_TYPES.FOLD,
     filter: TOKEN_TYPES.FILTER,
 };
-//# sourceMappingURL=operators.js.map

package/dist/lexer/readers.d.ts

@@ -26,4 +26,3 @@ export declare function readTripleQuoteString(state: LexerState): Token;
 export declare function readNumber(state: LexerState): Token;
 export declare function readIdentifier(state: LexerState): Token;
 export declare function readVariable(state: LexerState): Token;
-//# sourceMappingURL=readers.d.ts.map

package/dist/lexer/readers.js

@@ -227,4 +227,3 @@ export function readVariable(state) {
     // Lone $ is the pipe variable (current item in iteration)
     return makeToken(TOKEN_TYPES.PIPE_VAR, '$', start, currentLocation(state));
 }
-//# sourceMappingURL=readers.js.map

package/dist/lexer/state.d.ts

@@ -17,4 +17,3 @@ export declare function peek(state: LexerState, offset?: number): string;
 export declare function peekString(state: LexerState, length: number): string;
 export declare function advance(state: LexerState): string;
 export declare function isAtEnd(state: LexerState): boolean;
-//# sourceMappingURL=state.d.ts.map

package/dist/lexer/state.js

@@ -40,4 +40,3 @@ export function advance(state) {
 export function isAtEnd(state) {
     return state.pos >= state.source.length;
 }
-//# sourceMappingURL=state.js.map

package/dist/lexer/tokenizer.d.ts

@@ -9,4 +9,3 @@ export interface TokenizeOptions {
     includeComments?: boolean;
 }
 export declare function tokenize(source: string, baseLocation?: SourceLocation, options?: TokenizeOptions): Token[];
-//# sourceMappingURL=tokenizer.d.ts.map

package/dist/lexer/tokenizer.js

@@ -122,4 +122,3 @@ export function tokenize(source, baseLocation, options) {
     }
     return tokens;
 }
-//# sourceMappingURL=tokenizer.js.map

package/dist/parser/helpers.d.ts

@@ -95,4 +95,3 @@ export declare function makeBoolLiteralBlock(value: boolean, span: SourceSpan):
  * @internal
  */
 export declare function parseBareHostCall(state: ParserState): HostCallNode | HostRefNode;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/parser/helpers.js

@@ -302,4 +302,3 @@ export function parseBareHostCall(state) {
         span,
     };
 }
-//# sourceMappingURL=helpers.js.map

package/dist/parser/index.d.ts

@@ -49,4 +49,3 @@ export declare function parseWithRecovery(source: string): ParseResult;
 export { createParserState, type ParserState, advance, check, current, expect, skipNewlines, isAtEnd, } from './state.js';
 export { parseTypeRef } from './parser-types.js';
 export { Parser } from './parser.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.js

@@ -107,4 +107,3 @@ export { createParserState, advance, check, current, expect, skipNewlines, isAtE
 export { parseTypeRef } from './parser-types.js';
 // Parser class (for advanced usage)
 export { Parser } from './parser.js';
-//# sourceMappingURL=index.js.map

package/dist/parser/parser-collect.d.ts

@@ -13,4 +13,3 @@ declare module './parser.js' {
         parseFilterExpr(): FilterExprNode;
     }
 }
-//# sourceMappingURL=parser-collect.d.ts.map

package/dist/parser/parser-collect.js

@@ -151,4 +151,3 @@ Parser.prototype.parseFilterExpr = function () {
         span: makeSpan(start, current(this.state).span.end),
     };
 };
-//# sourceMappingURL=parser-collect.js.map

package/dist/parser/parser-control.d.ts

@@ -19,4 +19,3 @@ declare module './parser.js' {
         parseError(requireMessage?: boolean): ErrorNode;
     }
 }
-//# sourceMappingURL=parser-control.d.ts.map

package/dist/parser/parser-control.js

@@ -224,4 +224,3 @@ Parser.prototype.parseError = function (requireMessage = false) {
         span: makeSpan(start, current(this.state).span.end),
     };
 };
-//# sourceMappingURL=parser-control.js.map

package/dist/parser/parser-expr.d.ts

@@ -37,4 +37,3 @@ declare module './parser.js' {
     }
 }
 export {};
-//# sourceMappingURL=parser-expr.d.ts.map

package/dist/parser/parser-expr.js

@@ -1084,4 +1084,3 @@ Parser.prototype.parseConvert = function () {
         span: makeSpan(start, current(this.state).span.end),
     };
 };
-//# sourceMappingURL=parser-expr.js.map

package/dist/parser/parser-extract.d.ts

@@ -12,4 +12,3 @@ declare module './parser.js' {
         parseSliceBound(): SliceBoundNode;
     }
 }
-//# sourceMappingURL=parser-extract.d.ts.map

package/dist/parser/parser-extract.js

@@ -192,4 +192,3 @@ Parser.prototype.parseSliceBound = function () {
     }
     throw new ParseError('RILL-P001', `Expected slice bound (number, variable, or grouped expression), got: ${current(this.state).value}`, current(this.state).span.start);
 };
-//# sourceMappingURL=parser-extract.js.map

package/dist/parser/parser-functions.d.ts

@@ -18,4 +18,3 @@ declare module './parser.js' {
         }): TypeAssertionNode | TypeCheckNode;
     }
 }
-//# sourceMappingURL=parser-functions.d.ts.map

package/dist/parser/parser-functions.js

@@ -243,4 +243,3 @@ Parser.prototype.parsePostfixTypeOperation = function (primary, start) {
     }
     return { type: 'TypeAssertion', operand, typeRef, span };
 };
-//# sourceMappingURL=parser-functions.js.map

package/dist/parser/parser-literals.d.ts

@@ -21,4 +21,3 @@ declare module './parser.js' {
         parseCollectionLiteral(collectionType: 'list' | 'dict' | 'tuple' | 'ordered'): ListLiteralNode | DictLiteralNode | TupleLiteralNode | OrderedLiteralNode;
     }
 }
-//# sourceMappingURL=parser-literals.d.ts.map

package/dist/parser/parser-literals.js

@@ -525,7 +525,10 @@ Parser.prototype.parseClosureParam = function () {
     if (check(this.state, TOKEN_TYPES.COLON)) {
         advance(this.state);
         skipNewlines(this.state);
-        typeRef = parseTypeRef(this.state, { allowTrailingPipe: true });
+        typeRef = parseTypeRef(this.state, {
+            allowTrailingPipe: true,
+            parseLiteral: () => this.parseLiteral(),
+        });
     }
     skipNewlines(this.state);
     if (check(this.state, TOKEN_TYPES.ASSIGN)) {
@@ -702,4 +705,3 @@ Parser.prototype.parseCollectionLiteral = function (collectionType) {
     }
     return { type: 'OrderedLiteral', entries, span };
 };
-//# sourceMappingURL=parser-literals.js.map

package/dist/parser/parser-script.d.ts

@@ -18,4 +18,3 @@ declare module './parser.js' {
         }, message: string): RecoveryErrorNode;
     }
 }
-//# sourceMappingURL=parser-script.d.ts.map

package/dist/parser/parser-script.js

@@ -233,4 +233,3 @@ Parser.prototype.parseAnnotationArg = function () {
         span: makeSpan(start, current(this.state).span.end),
     };
 };
-//# sourceMappingURL=parser-script.js.map

package/dist/parser/parser-shape.d.ts

@@ -1,8 +1,8 @@
 /**
  * Parser Extension: Type Constructor Parsing
  * type-constructor = ("list" | "dict" | "tuple" | "ordered") "(" [type-arg-list] ")" ;
- * type-arg-list    = type-arg ("," type-arg)* [","] ;
- * type-arg         = identifier ":" expression | expression ;
+ * type-arg-list    = field-arg ("," field-arg)* [","] ;
+ * field-arg        = identifier ":" type-ref | type-ref ;
  */
 import type { TypeConstructorNode } from '../types.js';
 declare module './parser.js' {
@@ -10,4 +10,3 @@ declare module './parser.js' {
         parseTypeConstructor(constructorName: string): TypeConstructorNode;
     }
 }
-//# sourceMappingURL=parser-shape.d.ts.map

package/dist/parser/parser-shape.js

@@ -1,12 +1,13 @@
 /**
  * Parser Extension: Type Constructor Parsing
  * type-constructor = ("list" | "dict" | "tuple" | "ordered") "(" [type-arg-list] ")" ;
- * type-arg-list    = type-arg ("," type-arg)* [","] ;
- * type-arg         = identifier ":" expression | expression ;
+ * type-arg-list    = field-arg ("," field-arg)* [","] ;
+ * field-arg        = identifier ":" type-ref | type-ref ;
  */
 import { Parser } from './parser.js';
 import { ParseError, TOKEN_TYPES } from '../types.js';
-import { check, advance, expect, current, skipNewlines, makeSpan, peek, } from './state.js';
+import { advance, expect, current, makeSpan } from './state.js';
+import { parseFieldArgList } from './parser-types.js';
 // ============================================================
 // TYPE CONSTRUCTOR PARSING
 // ============================================================
@@ -25,20 +26,10 @@ Parser.prototype.parseTypeConstructor = function (constructorName) {
     // Consume the constructor name identifier token
     advance(this.state);
     expect(this.state, TOKEN_TYPES.LPAREN, 'Expected (');
-    skipNewlines(this.state);
-    const args = [];
-    if (!check(this.state, TOKEN_TYPES.RPAREN)) {
-        args.push(parseTypeArg(this));
-        skipNewlines(this.state);
-        while (check(this.state, TOKEN_TYPES.COMMA)) {
-            advance(this.state);
-            skipNewlines(this.state);
-            if (check(this.state, TOKEN_TYPES.RPAREN))
-                break; // trailing comma
-            args.push(parseTypeArg(this));
-            skipNewlines(this.state);
-        }
-    }
+    const parseLiteral = () => this.parseLiteral();
+    const args = parseFieldArgList(this.state, {
+        parseLiteral,
+    });
     const rparen = expect(this.state, TOKEN_TYPES.RPAREN, 'Expected )', 'RILL-P005');
     return {
         type: 'TypeConstructor',
@@ -47,38 +38,3 @@ Parser.prototype.parseTypeConstructor = function (constructorName) {
         span: makeSpan(start, rparen.span.end),
     };
 };
-// ============================================================
-// TYPE ARG PARSING (internal)
-// ============================================================
-/**
- * Parse a single type argument: `identifier ":" expression` (named) or `expression` (positional).
- * Lookahead: if current is IDENTIFIER and next is COLON, parse as named arg.
- * Otherwise parse as positional.
- */
-function parseTypeArg(parser) {
-    // Named arg: identifier ":" expression [= literal]
-    if (check(parser.state, TOKEN_TYPES.IDENTIFIER) &&
-        peek(parser.state, 1).type === TOKEN_TYPES.COLON) {
-        const nameToken = advance(parser.state); // consume identifier
-        advance(parser.state); // consume ':'
-        skipNewlines(parser.state);
-        const value = parser.parseExpression();
-        if (check(parser.state, TOKEN_TYPES.ASSIGN)) {
-            advance(parser.state); // consume =
-            skipNewlines(parser.state);
-            const defaultValue = parser.parseLiteral();
-            return { kind: 'named', name: nameToken.value, value, defaultValue };
-        }
-        return { kind: 'named', name: nameToken.value, value };
-    }
-    // Positional arg: expression [= literal]
-    const value = parser.parseExpression();
-    if (check(parser.state, TOKEN_TYPES.ASSIGN)) {
-        advance(parser.state); // consume =
-        skipNewlines(parser.state);
-        const defaultValue = parser.parseLiteral();
-        return { kind: 'positional', value, defaultValue };
-    }
-    return { kind: 'positional', value };
-}
-//# sourceMappingURL=parser-shape.js.map

package/dist/parser/parser-types.d.ts

@@ -4,7 +4,7 @@
  * parameterized) or a dynamic $variable.
  * @internal
  */
-import { type TypeRef } from '../types.js';
+import { type TypeRef, type FieldArg, type LiteralNode } from '../types.js';
 import { type ParserState } from './state.js';
 /**
  * Parse a type reference from the current position in the token stream.
@@ -33,5 +33,31 @@ import { type ParserState } from './state.js';
  */
 export declare function parseTypeRef(state: ParserState, opts?: {
     allowTrailingPipe?: boolean;
+    parseLiteral?: () => LiteralNode;
 }): TypeRef;
-//# sourceMappingURL=parser-types.d.ts.map
+/**
+ * Parse a comma-separated list of field arguments between `(` and `)`.
+ *
+ * Caller has already consumed the opening `(`. This function parses zero
+ * or more arguments up to the closing `)` but does NOT consume it.
+ *
+ * Supports:
+ * - Named args:      `name: type`  → `{ name, value }`
+ * - Positional args: `type`        → `{ value }`
+ * - Default values:  `= literal`   → `{ ..., defaultValue }` (when parseLiteral provided)
+ * - Union types in value position via `parseTypeRef`
+ * - Trailing commas before `)`
+ *
+ * Named arg detection: IDENTIFIER followed by COLON lookahead.
+ *
+ * @param state - Parser state (positioned after opening paren)
+ * @param opts  - Optional parseLiteral callback for default value support
+ *
+ * @throws ParseError RILL-P014 if token after arg is not `,` or `)`  (EC-1)
+ * @throws ParseError RILL-P014 if missing closing `)`                (EC-2)
+ *
+ * @internal
+ */
+export declare function parseFieldArgList(state: ParserState, opts?: {
+    parseLiteral?: () => LiteralNode;
+}): FieldArg[];

package/dist/parser/parser-types.js

@@ -5,7 +5,7 @@
  * @internal
  */
 import { TOKEN_TYPES, ParseError, } from '../types.js';
-import { check, advance, expect, current, peek, } from './state.js';
+import { check, advance, expect, current, peek, skipNewlines, } from './state.js';
 import { VALID_TYPE_NAMES, parseTypeName } from './helpers.js';
 /**
  * Parse a type reference from the current position in the token stream.
@@ -33,7 +33,7 @@ import { VALID_TYPE_NAMES, parseTypeName } from './helpers.js';
  * @internal
  */
 export function parseTypeRef(state, opts) {
-    const first = parseSingleType(state);
+    const first = parseSingleType(state, opts);
     // Union accumulation: collect additional members after each "|"
     if (!check(state, TOKEN_TYPES.PIPE_BAR)) {
         return first;
@@ -75,7 +75,7 @@ export function parseTypeRef(state, opts) {
             throw new ParseError('RILL-P011', "Expected type name after '|'", current(state).span.start);
         }
         advance(state); // consume "|"
-        const next = parseSingleType(state);
+        const next = parseSingleType(state, opts);
         // Flatten nested unions
         if (next.kind === 'union') {
             members.push(...next.members);
@@ -97,7 +97,19 @@ export function parseTypeRef(state, opts) {
  * Grammar: `single-type = "$" identifier | type-name [ "(" type-ref-arg-list ")" ]`
  * @internal
  */
-function parseSingleType(state) {
+function parseSingleType(state, opts) {
+    // Zero-param closure type: || :returnType or bare ||
+    if (check(state, TOKEN_TYPES.OR)) {
+        advance(state); // consume || (OR token)
+        // Check for :returnType
+        if (check(state, TOKEN_TYPES.COLON)) {
+            advance(state); // consume :
+            const ret = parseSingleType(state, opts);
+            return { kind: 'static', typeName: 'closure', args: [{ value: ret }] };
+        }
+        // Bare || without :returnType — equivalent to 'closure'
+        return { kind: 'static', typeName: 'closure' };
+    }
     if (check(state, TOKEN_TYPES.DOLLAR)) {
         advance(state); // consume $
         const nameToken = expect(state, TOKEN_TYPES.IDENTIFIER, 'Expected variable name after $');
@@ -109,7 +121,39 @@ function parseSingleType(state) {
         return { kind: 'static', typeName };
     }
     advance(state); // consume "("
+    const args = parseFieldArgList(state, opts?.parseLiteral ? { parseLiteral: opts.parseLiteral } : undefined);
+    advance(state); // consume ")"
+    return { kind: 'static', typeName, args };
+}
+// ============================================================
+// FIELD ARG LIST PARSING
+// ============================================================
+/**
+ * Parse a comma-separated list of field arguments between `(` and `)`.
+ *
+ * Caller has already consumed the opening `(`. This function parses zero
+ * or more arguments up to the closing `)` but does NOT consume it.
+ *
+ * Supports:
+ * - Named args:      `name: type`  → `{ name, value }`
+ * - Positional args: `type`        → `{ value }`
+ * - Default values:  `= literal`   → `{ ..., defaultValue }` (when parseLiteral provided)
+ * - Union types in value position via `parseTypeRef`
+ * - Trailing commas before `)`
+ *
+ * Named arg detection: IDENTIFIER followed by COLON lookahead.
+ *
+ * @param state - Parser state (positioned after opening paren)
+ * @param opts  - Optional parseLiteral callback for default value support
+ *
+ * @throws ParseError RILL-P014 if token after arg is not `,` or `)`  (EC-1)
+ * @throws ParseError RILL-P014 if missing closing `)`                (EC-2)
+ *
+ * @internal
+ */
+export function parseFieldArgList(state, opts) {
     const args = [];
+    skipNewlines(state);
     // Parse arg list: allow empty "()" and trailing commas
     while (!check(state, TOKEN_TYPES.RPAREN)) {
         // Check for named arg: identifier ":" type-ref
@@ -120,28 +164,47 @@ function parseSingleType(state) {
             const name = tok.value;
             advance(state); // consume identifier
             advance(state); // consume ":"
-            const ref = parseTypeRef(state);
-            args.push({ name, ref });
+            skipNewlines(state);
+            const typeRefOpts = opts?.parseLiteral
+                ? { parseLiteral: opts.parseLiteral }
+                : undefined;
+            const value = parseTypeRef(state, typeRefOpts);
+            const arg = { name, value };
+            if (opts?.parseLiteral && check(state, TOKEN_TYPES.ASSIGN)) {
+                advance(state); // consume =
+                skipNewlines(state);
+                arg.defaultValue = opts.parseLiteral();
+            }
+            args.push(arg);
         }
         else {
             // Positional arg: type-ref
-            const ref = parseTypeRef(state);
-            args.push({ ref });
+            const typeRefOpts = opts?.parseLiteral
+                ? { parseLiteral: opts.parseLiteral }
+                : undefined;
+            const value = parseTypeRef(state, typeRefOpts);
+            const arg = { value };
+            if (opts?.parseLiteral && check(state, TOKEN_TYPES.ASSIGN)) {
+                advance(state); // consume =
+                skipNewlines(state);
+                arg.defaultValue = opts.parseLiteral();
+            }
+            args.push(arg);
         }
+        skipNewlines(state);
         // Consume trailing or separating comma
         if (check(state, TOKEN_TYPES.COMMA)) {
             advance(state);
+            skipNewlines(state);
         }
         else if (!check(state, TOKEN_TYPES.RPAREN)) {
-            // Neither comma nor closing paren — malformed arg list (EC-14)
+            // Neither comma nor closing paren — malformed arg list (EC-1)
             throw new ParseError('RILL-P014', "Expected ',' or ')' in type argument list", current(state).span.start);
         }
     }
-    // Consume ")"
+    // Verify closing ")" is present (EC-2)
     if (!check(state, TOKEN_TYPES.RPAREN)) {
         throw new ParseError('RILL-P014', "Expected ')' to close type argument list", current(state).span.start);
     }
-    advance(state); // consume ")"
-    return { kind: 'static', typeName, args };
+    return args;
 }
-//# sourceMappingURL=parser-types.js.map

package/dist/parser/parser-use.d.ts

@@ -8,4 +8,3 @@ declare module './parser.js' {
         parseUseExpr(): UseExprNode;
     }
 }
-//# sourceMappingURL=parser-use.d.ts.map