@prisma-next/psl-parser 0.13.0 → 0.14.0-dev.10

package/src/parser.ts

@@ -1,1713 +0,0 @@
-import type {
-  AuthoringPslBlockDescriptor,
-  AuthoringPslBlockDescriptorNamespace,
-} from '@prisma-next/framework-components/authoring';
-import { isAuthoringPslBlockDescriptor } from '@prisma-next/framework-components/authoring';
-import { emptyCodecLookup } from '@prisma-next/framework-components/codec';
-import type {
-  ParsePslDocumentInput,
-  ParsePslDocumentResult,
-  PslAttribute,
-  PslAttributeArgument,
-  PslAttributeTarget,
-  PslCompositeType,
-  PslDiagnostic,
-  PslDiagnosticCode,
-  PslDocumentAst,
-  PslEnum,
-  PslEnumValue,
-  PslExtensionBlock,
-  PslExtensionBlockParamValue,
-  PslField,
-  PslFieldAttribute,
-  PslModel,
-  PslModelAttribute,
-  PslNamedTypeDeclaration,
-  PslNamespace,
-  PslPosition,
-  PslSpan,
-  PslTypeConstructorCall,
-  PslTypesBlock,
-} from '@prisma-next/framework-components/psl-ast';
-import {
-  makePslNamespace,
-  makePslNamespaceEntries,
-  namespacePslExtensionBlocks,
-  UNSPECIFIED_PSL_NAMESPACE_ID,
-  validateExtensionBlock,
-} from '@prisma-next/framework-components/psl-ast';
-import { ifDefined } from '@prisma-next/utils/defined';
-
-const SCALAR_TYPES = new Set([
-  'String',
-  'Boolean',
-  'Int',
-  'BigInt',
-  'Float',
-  'Decimal',
-  'DateTime',
-  'Json',
-  'Bytes',
-]);
-
-interface BlockBounds {
-  readonly startLine: number;
-  readonly endLine: number;
-  readonly closed: boolean;
-}
-
-interface ParserContext {
-  readonly schema: string;
-  readonly sourceId: string;
-  readonly lines: readonly string[];
-  readonly lineOffsets: readonly number[];
-  readonly diagnostics: PslDiagnostic[];
-}
-
-export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocumentResult {
-  const normalizedSchema = input.schema.replaceAll('\r\n', '\n');
-  const lines = normalizedSchema.split('\n');
-  const lineOffsets = computeLineOffsets(normalizedSchema);
-  const diagnostics: PslDiagnostic[] = [];
-  const context: ParserContext = {
-    schema: normalizedSchema,
-    sourceId: input.sourceId,
-    lines,
-    lineOffsets,
-    diagnostics,
-  };
-
-  interface NamespaceAccumulator {
-    name: string;
-    models: PslModel[];
-    enums: PslEnum[];
-    compositeTypes: PslCompositeType[];
-    extensionBlocks: PslExtensionBlock[];
-    span: PslSpan | undefined;
-  }
-
-  const namespaceOrder: string[] = [];
-  const namespacesByName = new Map<string, NamespaceAccumulator>();
-  const getOrCreateNamespace = (
-    name: string,
-    spanIfNew: PslSpan | undefined,
-  ): NamespaceAccumulator => {
-    let acc = namespacesByName.get(name);
-    if (!acc) {
-      acc = {
-        name,
-        models: [],
-        enums: [],
-        compositeTypes: [],
-        extensionBlocks: [],
-        span: spanIfNew,
-      };
-      namespacesByName.set(name, acc);
-      namespaceOrder.push(name);
-    }
-    return acc;
-  };
-
-  let typesBlock: PslTypesBlock | undefined;
-  const pslBlockNamespace: AuthoringPslBlockDescriptorNamespace = input.pslBlockDescriptors ?? {};
-
-  // Walk a contiguous range of lines, routing top-level declarations into the
-  // active namespace bucket. Called once for the whole document and once per
-  // `namespace { … }` block body; nested `namespace { … }` or `types { … }`
-  // blocks inside a namespace body are rejected with a diagnostic.
-  const parseBody = (
-    startLine: number,
-    endLineExclusive: number,
-    currentNamespaceName: string,
-    isInsideNamespace: boolean,
-  ): void => {
-    let lineIndex = startLine;
-    while (lineIndex < endLineExclusive) {
-      const rawLine = context.lines[lineIndex] ?? '';
-      const line = stripInlineComment(rawLine).trim();
-      if (line.length === 0) {
-        lineIndex += 1;
-        continue;
-      }
-
-      const modelMatch = line.match(/^model\s+([A-Za-z_]\w*)\s*\{$/);
-      if (modelMatch) {
-        const bounds = findBlockBounds(context, lineIndex);
-        const name = modelMatch[1] ?? '';
-        if (name.length > 0) {
-          const acc = getOrCreateNamespace(
-            currentNamespaceName,
-            createTrimmedLineSpan(context, lineIndex),
-          );
-          acc.models.push(parseModelBlock(context, name, bounds));
-        }
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
-      const enumMatch = line.match(/^enum\s+([A-Za-z_]\w*)\s*\{$/);
-      if (enumMatch) {
-        const bounds = findBlockBounds(context, lineIndex);
-        const name = enumMatch[1] ?? '';
-        if (name.length > 0) {
-          const acc = getOrCreateNamespace(
-            currentNamespaceName,
-            createTrimmedLineSpan(context, lineIndex),
-          );
-          acc.enums.push(parseEnumBlock(context, name, bounds));
-        }
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
-      const compositeTypeMatch = line.match(/^type\s+([A-Za-z_]\w*)\s*\{$/);
-      if (compositeTypeMatch) {
-        const bounds = findBlockBounds(context, lineIndex);
-        const name = compositeTypeMatch[1] ?? '';
-        if (name.length > 0) {
-          const acc = getOrCreateNamespace(
-            currentNamespaceName,
-            createTrimmedLineSpan(context, lineIndex),
-          );
-          acc.compositeTypes.push(parseCompositeTypeBlock(context, name, bounds));
-        }
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
-      const namespaceMatch = line.match(/^namespace\s+([A-Za-z_]\w*)\s*\{$/);
-      if (namespaceMatch) {
-        const bounds = findBlockBounds(context, lineIndex);
-        const name = namespaceMatch[1] ?? '';
-        if (isInsideNamespace) {
-          pushDiagnostic(context, {
-            code: 'PSL_INVALID_NAMESPACE_BLOCK',
-            message: `Recursive "namespace ${name}" block is not allowed; namespace blocks may not nest`,
-            span: createTrimmedLineSpan(context, lineIndex),
-          });
-        } else if (name === UNSPECIFIED_PSL_NAMESPACE_ID) {
-          pushDiagnostic(context, {
-            code: 'PSL_INVALID_NAMESPACE_BLOCK',
-            message: `Namespace name "${UNSPECIFIED_PSL_NAMESPACE_ID}" is reserved for the parser-synthesised bucket for top-level declarations`,
-            span: createTrimmedLineSpan(context, lineIndex),
-          });
-        } else if (name.length > 0) {
-          getOrCreateNamespace(name, createTrimmedLineSpan(context, lineIndex));
-          parseBody(bounds.startLine + 1, bounds.endLine, name, true);
-        }
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
-      if (/^types\s*\{$/.test(line)) {
-        const bounds = findBlockBounds(context, lineIndex);
-        if (isInsideNamespace) {
-          pushDiagnostic(context, {
-            code: 'PSL_INVALID_NAMESPACE_BLOCK',
-            message:
-              '`types` blocks must be declared at the document top level, not inside a namespace block',
-            span: createTrimmedLineSpan(context, lineIndex),
-          });
-        } else if (typesBlock !== undefined) {
-          pushDiagnostic(context, {
-            code: 'PSL_INVALID_TYPES_MEMBER',
-            message: 'Only one top-level `types` block is allowed per document',
-            span: createTrimmedLineSpan(context, lineIndex),
-          });
-        } else {
-          typesBlock = parseTypesBlock(context, bounds);
-        }
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
-      const extensionBlockMatch = line.match(/^([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*\{$/);
-      if (extensionBlockMatch) {
-        const keyword = extensionBlockMatch[1] ?? '';
-        const blockName = extensionBlockMatch[2] ?? '';
-        const descriptor = lookupExtensionBlockDescriptor(pslBlockNamespace, keyword);
-        if (descriptor) {
-          const bounds = findBlockBounds(context, lineIndex);
-          if (blockName.length > 0) {
-            const acc = getOrCreateNamespace(
-              currentNamespaceName,
-              createTrimmedLineSpan(context, lineIndex),
-            );
-            const node = parseExtensionBlock(context, descriptor, blockName, lineIndex, bounds);
-            acc.extensionBlocks.push(node);
-          }
-          lineIndex = bounds.endLine + 1;
-          continue;
-        }
-      }
-
-      if (line.includes('{')) {
-        const blockName = line.split(/\s+/)[0] ?? 'block';
-        pushDiagnostic(context, {
-          code: 'PSL_UNSUPPORTED_TOP_LEVEL_BLOCK',
-          message: `Unsupported top-level block "${blockName}"`,
-          span: createTrimmedLineSpan(context, lineIndex),
-        });
-        const bounds = findBlockBounds(context, lineIndex);
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
-      pushDiagnostic(context, {
-        code: 'PSL_UNSUPPORTED_TOP_LEVEL_BLOCK',
-        message: `Unsupported top-level declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      lineIndex += 1;
-    }
-  };
-
-  parseBody(0, lines.length, UNSPECIFIED_PSL_NAMESPACE_ID, false);
-
-  // Named-type validation: types are document-scoped (one block, outside any
-  // namespace), so collision checks compare named-type names against every
-  // model/enum/composite-type in every namespace.
-  const allModels: PslModel[] = [];
-  const allEnums: PslEnum[] = [];
-  const allCompositeTypes: PslCompositeType[] = [];
-  for (const name of namespaceOrder) {
-    const acc = namespacesByName.get(name);
-    if (!acc) continue;
-    allModels.push(...acc.models);
-    allEnums.push(...acc.enums);
-    allCompositeTypes.push(...acc.compositeTypes);
-  }
-
-  const namedTypeNames = new Set(
-    (typesBlock?.declarations ?? []).map((declaration) => declaration.name),
-  );
-  const modelNames = new Set(allModels.map((model) => model.name));
-  const enumNames = new Set(allEnums.map((enumBlock) => enumBlock.name));
-  const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
-  for (const declaration of typesBlock?.declarations ?? []) {
-    if (SCALAR_TYPES.has(declaration.name)) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_TYPES_MEMBER',
-        message: `Named type "${declaration.name}" conflicts with scalar type "${declaration.name}"`,
-        span: declaration.span,
-      });
-      continue;
-    }
-    if (modelNames.has(declaration.name)) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_TYPES_MEMBER',
-        message: `Named type "${declaration.name}" conflicts with model name "${declaration.name}"`,
-        span: declaration.span,
-      });
-      continue;
-    }
-    if (enumNames.has(declaration.name)) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_TYPES_MEMBER',
-        message: `Named type "${declaration.name}" conflicts with enum name "${declaration.name}"`,
-        span: declaration.span,
-      });
-    }
-  }
-
-  const documentSpan: PslSpan = {
-    start: createPosition(context, 0, 0),
-    end: createPosition(
-      context,
-      Math.max(lines.length - 1, 0),
-      (lines[Math.max(lines.length - 1, 0)] ?? '').length,
-    ),
-  };
-
-  const namespaces: PslNamespace[] = [];
-  for (const name of namespaceOrder) {
-    const acc = namespacesByName.get(name);
-    if (!acc) continue;
-    // Drop the synthesised __unspecified__ entry when it ended up empty (e.g.
-    // every declaration in the document lived inside an explicit
-    // `namespace { … }` block). Keeping a phantom bucket would force every
-    // downstream consumer to special-case "namespace with no members".
-    if (
-      name === UNSPECIFIED_PSL_NAMESPACE_ID &&
-      acc.models.length === 0 &&
-      acc.enums.length === 0 &&
-      acc.compositeTypes.length === 0 &&
-      acc.extensionBlocks.length === 0
-    ) {
-      continue;
-    }
-    const normalizedModels = acc.models.map((model) => ({
-      ...model,
-      fields: model.fields.map((field) => {
-        if (!namedTypeNames.has(field.typeName)) {
-          return field;
-        }
-        const hasRelationAttribute = field.attributes.some(
-          (attribute) => attribute.name === 'relation',
-        );
-        if (
-          hasRelationAttribute ||
-          modelNames.has(field.typeName) ||
-          enumNames.has(field.typeName) ||
-          compositeTypeNames.has(field.typeName) ||
-          SCALAR_TYPES.has(field.typeName)
-        ) {
-          return field;
-        }
-        return {
-          ...field,
-          typeRef: field.typeName,
-        };
-      }),
-    }));
-    namespaces.push(
-      makePslNamespace({
-        kind: 'namespace',
-        name,
-        entries: makePslNamespaceEntries(
-          normalizedModels,
-          acc.enums,
-          acc.compositeTypes,
-          acc.extensionBlocks,
-        ),
-        span: acc.span ?? documentSpan,
-      }),
-    );
-  }
-
-  // Validate extension blocks with the generic validator after the full
-  // AST is assembled. The validator needs all namespaces for ref resolution.
-  // It runs whenever pslBlockDescriptors are registered — codecLookup falls
-  // back to emptyCodecLookup when not provided, which rejects value-kind
-  // parameters with unknown codecs. Callers with value parameters should
-  // always supply a codecLookup.
-  if (Object.keys(pslBlockNamespace).length > 0) {
-    const codecLookup = input.codecLookup ?? emptyCodecLookup;
-    // Build a discriminator → descriptor reverse map from the descriptor
-    // namespace. The parser keyed by keyword; the validator resolves by
-    // node.kind (= discriminator) so we need the reverse direction.
-    const descriptorByDiscriminator = new Map<string, AuthoringPslBlockDescriptor>();
-    for (const value of Object.values(pslBlockNamespace)) {
-      if (isAuthoringPslBlockDescriptor(value)) {
-        descriptorByDiscriminator.set(value.discriminator, value);
-      }
-    }
-    for (const ns of namespaces) {
-      // Collect extension blocks from entries using the canonical helper, then
-      // filter to only those whose discriminator is registered in the namespace.
-      for (const block of namespacePslExtensionBlocks(ns)) {
-        const descriptor = descriptorByDiscriminator.get(block.kind);
-        if (descriptor === undefined) {
-          continue;
-        }
-        const blockDiagnostics = validateExtensionBlock(
-          block,
-          descriptor,
-          input.sourceId,
-          codecLookup,
-          {
-            ownerNamespace: ns,
-            allNamespaces: namespaces,
-          },
-        );
-        diagnostics.push(...blockDiagnostics);
-      }
-    }
-  }
-
-  const ast: PslDocumentAst = {
-    kind: 'document',
-    sourceId: input.sourceId,
-    namespaces,
-    ...ifDefined('types', typesBlock),
-    span: documentSpan,
-  };
-
-  return {
-    ast,
-    diagnostics,
-    ok: diagnostics.length === 0,
-  };
-}
-
-function parseModelBlock(context: ParserContext, name: string, bounds: BlockBounds): PslModel {
-  const fields: PslField[] = [];
-  const attributes: PslModelAttribute[] = [];
-
-  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
-    const raw = context.lines[lineIndex] ?? '';
-    const line = stripInlineComment(raw).trim();
-    if (line.length === 0) {
-      continue;
-    }
-
-    if (line.startsWith('@@')) {
-      const attribute = parseModelAttribute(context, line, lineIndex);
-      if (attribute) {
-        attributes.push(attribute);
-      }
-      continue;
-    }
-
-    const field = parseField(context, line, lineIndex);
-    if (field) {
-      fields.push(field);
-    }
-  }
-
-  return {
-    kind: 'model',
-    name,
-    fields,
-    attributes,
-    span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
-  };
-}
-
-function parseCompositeTypeBlock(
-  context: ParserContext,
-  name: string,
-  bounds: BlockBounds,
-): PslCompositeType {
-  const fields: PslField[] = [];
-  const attributes: PslAttribute[] = [];
-
-  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
-    const raw = context.lines[lineIndex] ?? '';
-    const line = stripInlineComment(raw).trim();
-    if (line.length === 0) {
-      continue;
-    }
-
-    if (line.startsWith('@@')) {
-      const attribute = parseModelAttribute(context, line, lineIndex);
-      if (attribute) {
-        attributes.push(attribute);
-      }
-      continue;
-    }
-
-    const field = parseField(context, line, lineIndex);
-    if (field) {
-      fields.push(field);
-    }
-  }
-
-  return {
-    kind: 'compositeType',
-    name,
-    fields,
-    attributes,
-    span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
-  };
-}
-
-function parseEnumBlock(context: ParserContext, name: string, bounds: BlockBounds): PslEnum {
-  const values: PslEnumValue[] = [];
-  const attributes: PslAttribute[] = [];
-
-  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
-    const raw = context.lines[lineIndex] ?? '';
-    const line = stripInlineComment(raw).trim();
-    if (line.length === 0) {
-      continue;
-    }
-
-    if (line.startsWith('@@')) {
-      const attribute = parseEnumAttribute(context, line, lineIndex);
-      if (attribute) {
-        attributes.push(attribute);
-      }
-      continue;
-    }
-
-    // An enum member line is the bare member identifier, optionally followed
-    // by a `@map("storage-label")` attribute. The map attribute lets the
-    // printer round-trip enum values whose original storage label is not a
-    // valid PSL identifier (e.g. PostgreSQL enum labels with hyphens).
-    const valueMatch = line.match(/^([A-Za-z_]\w*)(?:\s+@map\(\s*"((?:[^"\\]|\\.)*)"\s*\))?$/);
-    if (!valueMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_ENUM_MEMBER',
-        message: `Invalid enum value declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      continue;
-    }
-
-    const mapName = valueMatch[2] !== undefined ? unescapePslString(valueMatch[2]) : undefined;
-
-    values.push({
-      kind: 'enumValue',
-      name: valueMatch[1] ?? '',
-      ...(mapName !== undefined ? { mapName } : {}),
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-  }
-
-  return {
-    kind: 'enum',
-    name,
-    values,
-    attributes,
-    span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
-  };
-}
-
-/**
- * Decode PSL escape sequences (`\\`, `\"`, `\'`, `\n`, `\r`) inside a
- * quoted-literal body. The argument is the body of the literal with the
- * surrounding quotes already stripped by the caller. Mirrors the inverse
- * helper in `@prisma-next/psl-printer`'s `escapePslString` so a string
- * round-trips parser → printer → parser unchanged.
- */
-function unescapePslString(value: string): string {
-  let result = '';
-  for (let i = 0; i < value.length; i++) {
-    const ch = value.charCodeAt(i);
-    if (ch !== 0x5c /* '\\' */ || i + 1 >= value.length) {
-      result += value[i];
-      continue;
-    }
-    const next = value[i + 1];
-    if (next === '\\' || next === '"' || next === "'") {
-      result += next;
-    } else if (next === 'n') {
-      result += '\n';
-    } else if (next === 'r') {
-      result += '\r';
-    } else {
-      result += '\\';
-      result += next;
-    }
-    i++;
-  }
-  return result;
-}
-
-function parseTypesBlock(context: ParserContext, bounds: BlockBounds): PslTypesBlock {
-  const declarations: PslNamedTypeDeclaration[] = [];
-
-  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
-    const raw = context.lines[lineIndex] ?? '';
-    const lineWithoutComment = stripInlineComment(raw);
-    const line = lineWithoutComment.trim();
-    if (line.length === 0) {
-      continue;
-    }
-
-    const declarationMatch = line.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
-    if (!declarationMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_TYPES_MEMBER',
-        message: `Invalid types declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      continue;
-    }
-
-    const declarationName = declarationMatch[1] ?? '';
-    const trimmedStartColumn = firstNonWhitespaceColumn(raw);
-    const declarationValue = (declarationMatch[2] ?? '').trim();
-    const valueOffset = line.indexOf(declarationValue);
-    const declarationValueColumn = trimmedStartColumn + Math.max(valueOffset, 0);
-
-    const typeAndAttributeSplit = splitTypeAndAttributes(declarationValue);
-    const typeSource = typeAndAttributeSplit.typeSource.trim();
-    const attributeSource = typeAndAttributeSplit.attributeSource.trimStart();
-    const leadingAttributeWhitespace =
-      typeAndAttributeSplit.attributeSource.length - attributeSource.length;
-
-    const typeConstructor = parseTypeConstructorCall(context, {
-      declarationValue: typeSource,
-      lineIndex,
-      startColumn: declarationValueColumn,
-      invalidCode: 'PSL_INVALID_TYPES_MEMBER',
-      invalidMessage: (value) => `Invalid types declaration "${value}"`,
-    });
-    if (typeConstructor === 'malformed') {
-      continue;
-    }
-
-    const attributeParse = extractAttributeTokensWithSpans(
-      context,
-      lineIndex,
-      attributeSource,
-      declarationValueColumn + typeAndAttributeSplit.attributeOffset + leadingAttributeWhitespace,
-    );
-    if (!attributeParse.ok) {
-      continue;
-    }
-    const attributes = attributeParse.tokens
-      .map((token) =>
-        parseAttributeToken(context, {
-          token: token.text,
-          target: 'namedType',
-          lineIndex,
-          span: token.span,
-        }),
-      )
-      .filter((attribute): attribute is PslAttribute => Boolean(attribute));
-
-    if (typeConstructor) {
-      declarations.push({
-        kind: 'namedType',
-        name: declarationName,
-        typeConstructor,
-        attributes,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      continue;
-    }
-
-    const baseTypeMatch = typeSource.match(/^([A-Za-z_]\w*)$/);
-    if (!baseTypeMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_TYPES_MEMBER',
-        message: `Invalid types declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      continue;
-    }
-
-    const baseType = baseTypeMatch[1] ?? '';
-
-    declarations.push({
-      kind: 'namedType',
-      name: declarationName,
-      baseType,
-      attributes,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-  }
-
-  return {
-    kind: 'types',
-    declarations,
-    span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
-  };
-}
-
-function parseTypeConstructorCall(
-  context: ParserContext,
-  input: {
-    readonly declarationValue: string;
-    readonly lineIndex: number;
-    readonly startColumn: number;
-    readonly invalidCode: PslDiagnosticCode;
-    readonly invalidMessage: (value: string) => string;
-  },
-): PslTypeConstructorCall | 'malformed' | undefined {
-  const value = input.declarationValue.trim();
-  const constructorMatch = value.match(
-    /^([A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)*)\s*\(/,
-  );
-  if (!constructorMatch) {
-    return undefined;
-  }
-
-  // constructorMatch already required `(`; openParen is guaranteed ≥ 0.
-  const openParen = value.indexOf('(');
-  const closeParen = value.lastIndexOf(')');
-
-  if (closeParen !== value.length - 1) {
-    pushDiagnostic(context, {
-      code: input.invalidCode,
-      message: input.invalidMessage(value),
-      span: createInlineSpan(
-        context,
-        input.lineIndex,
-        input.startColumn,
-        input.startColumn + value.length,
-      ),
-    });
-    return 'malformed';
-  }
-
-  const constructorPath = constructorMatch[1] ?? '';
-
-  const argsRaw = value.slice(openParen + 1, closeParen);
-  const args = parseArgumentList(context, {
-    argsRaw,
-    argsOffset: input.startColumn + openParen + 1,
-    lineIndex: input.lineIndex,
-    token: value,
-    span: createInlineSpan(
-      context,
-      input.lineIndex,
-      input.startColumn,
-      input.startColumn + value.length,
-    ),
-    invalidCode: input.invalidCode,
-    invalidEmptyArgumentMessage: `Invalid empty argument in type constructor "${value}"`,
-    invalidNamedArgumentMessage: (part) =>
-      `Invalid named argument syntax "${part}" in type constructor "${value}"`,
-  });
-  if (!args) {
-    return 'malformed';
-  }
-
-  return {
-    kind: 'typeConstructor',
-    path: constructorPath.split('.'),
-    args,
-    span: createInlineSpan(
-      context,
-      input.lineIndex,
-      input.startColumn,
-      input.startColumn + value.length,
-    ),
-  };
-}
-
-function parseModelAttribute(
-  context: ParserContext,
-  line: string,
-  lineIndex: number,
-): PslModelAttribute | undefined {
-  const rawLine = context.lines[lineIndex] ?? '';
-  const tokenParse = extractAttributeTokensWithSpans(
-    context,
-    lineIndex,
-    line,
-    firstNonWhitespaceColumn(rawLine),
-  );
-  if (!tokenParse.ok || tokenParse.tokens.length !== 1) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Invalid model attribute syntax "${line}"`,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-    return undefined;
-  }
-  const token = tokenParse.tokens[0];
-  if (!token) {
-    return undefined;
-  }
-  return parseAttributeToken(context, {
-    token: token.text,
-    target: 'model',
-    lineIndex,
-    span: token.span,
-  });
-}
-
-function parseEnumAttribute(
-  context: ParserContext,
-  line: string,
-  lineIndex: number,
-): PslAttribute | undefined {
-  const rawLine = context.lines[lineIndex] ?? '';
-  const tokenParse = extractAttributeTokensWithSpans(
-    context,
-    lineIndex,
-    line,
-    firstNonWhitespaceColumn(rawLine),
-  );
-  if (!tokenParse.ok || tokenParse.tokens.length !== 1) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ENUM_MEMBER',
-      message: `Invalid enum value declaration "${line}"`,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-    return undefined;
-  }
-  const token = tokenParse.tokens[0];
-  if (!token) {
-    return undefined;
-  }
-  const parsed = parseAttributeToken(context, {
-    token: token.text,
-    target: 'enum',
-    lineIndex,
-    span: token.span,
-  });
-  if (!parsed) {
-    return undefined;
-  }
-  if (parsed.name !== 'map') {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ENUM_MEMBER',
-      message: `Invalid enum value declaration "${line}"`,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-    return undefined;
-  }
-  return parsed;
-}
-
-function parseField(context: ParserContext, line: string, lineIndex: number): PslField | undefined {
-  const fieldMatch = line.match(/^([A-Za-z_]\w*)(\s+)(.+)$/);
-  if (!fieldMatch) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_MODEL_MEMBER',
-      message: `Invalid model member declaration "${line}"`,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-    return undefined;
-  }
-
-  const fieldName = fieldMatch[1] ?? '';
-  const separator = fieldMatch[2] ?? '';
-  const remainder = fieldMatch[3] ?? '';
-  const typeAndAttributeSplit = splitTypeAndAttributes(remainder);
-  const rawTypeSource = typeAndAttributeSplit.typeSource.trim();
-  const attributePart = typeAndAttributeSplit.attributeSource;
-  const optional = rawTypeSource.endsWith('?');
-  const typeSourceWithoutOptional = optional ? rawTypeSource.slice(0, -1).trimEnd() : rawTypeSource;
-  const list = typeSourceWithoutOptional.endsWith('[]');
-  const baseTypeSource = list
-    ? typeSourceWithoutOptional.slice(0, -2).trimEnd()
-    : typeSourceWithoutOptional;
-  const rawLine = context.lines[lineIndex] ?? '';
-  const trimmedStartColumn = firstNonWhitespaceColumn(rawLine);
-  const typeStartColumn = trimmedStartColumn + fieldName.length + separator.length;
-
-  const typeConstructor = parseTypeConstructorCall(context, {
-    declarationValue: baseTypeSource,
-    lineIndex,
-    startColumn: typeStartColumn,
-    invalidCode: 'PSL_INVALID_MODEL_MEMBER',
-    invalidMessage: (value) => `Invalid field type constructor "${value}"`,
-  });
-  if (typeConstructor === 'malformed') {
-    return undefined;
-  }
-
-  let typeName: string;
-  let typeNamespaceId: string | undefined;
-  let typeContractSpaceId: string | undefined;
-
-  if (typeConstructor) {
-    typeName = typeConstructor.path.join('.');
-  } else {
-    // Detect the colon-prefix cross-contract-space form: `<space>:<rest>` where
-    // `<rest>` is the existing dot-qualified or bare form (`<ns>.<Name>` or `<Name>`).
-    // Multiple colons (e.g. `a:b:c`) are invalid.
-    const colonCount = (baseTypeSource.match(/:/g) ?? []).length;
-    if (colonCount > 1) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_MODEL_MEMBER',
-        message: `Invalid model member declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      return undefined;
-    }
-
-    let typeRefSource: string;
-    if (colonCount === 1) {
-      // Colon-prefix form: `<space>:<rest>`
-      const colonIndex = baseTypeSource.indexOf(':');
-      const spaceCandidate = baseTypeSource.slice(0, colonIndex);
-      typeRefSource = baseTypeSource.slice(colonIndex + 1);
-      // Validate space identifier
-      if (!/^[A-Za-z_]\w*$/.test(spaceCandidate)) {
-        pushDiagnostic(context, {
-          code: 'PSL_INVALID_MODEL_MEMBER',
-          message: `Invalid model member declaration "${line}"`,
-          span: createTrimmedLineSpan(context, lineIndex),
-        });
-        return undefined;
-      }
-      typeContractSpaceId = spaceCandidate;
-    } else {
-      typeRefSource = baseTypeSource;
-    }
-
-    const dotCount = (typeRefSource.match(/\./g) ?? []).length;
-    if (dotCount > 1) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_QUALIFIED_TYPE',
-        message: `Nested dot-qualified type "${baseTypeSource}" is not supported; use exactly one qualifier segment (e.g. "ns.TypeName")`,
-        span: createInlineSpan(
-          context,
-          lineIndex,
-          typeStartColumn,
-          typeStartColumn + baseTypeSource.length,
-        ),
-      });
-      return undefined;
-    }
-    const singleMatch = typeRefSource.match(/^([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?$/);
-    if (!singleMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_MODEL_MEMBER',
-        message: `Invalid model member declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      return undefined;
-    }
-    if (singleMatch[2] !== undefined) {
-      typeNamespaceId = singleMatch[1];
-      typeName = singleMatch[2];
-    } else {
-      typeName = singleMatch[1] ?? '';
-    }
-  }
-
-  const attributes: PslFieldAttribute[] = [];
-  const attributeSource = attributePart.trimStart();
-  const leadingAttributeWhitespace = attributePart.length - attributeSource.length;
-  const tokenParse = extractAttributeTokensWithSpans(
-    context,
-    lineIndex,
-    attributeSource,
-    trimmedStartColumn +
-      fieldName.length +
-      separator.length +
-      typeAndAttributeSplit.attributeOffset +
-      leadingAttributeWhitespace,
-  );
-  if (!tokenParse.ok) {
-    return {
-      kind: 'field',
-      name: fieldName,
-      typeName,
-      ...ifDefined('typeNamespaceId', typeNamespaceId),
-      ...ifDefined('typeContractSpaceId', typeContractSpaceId),
-      ...ifDefined('typeConstructor', typeConstructor),
-      optional,
-      list,
-      attributes,
-      span: createTrimmedLineSpan(context, lineIndex),
-    };
-  }
-
-  for (const token of tokenParse.tokens) {
-    const parsed = parseAttributeToken(context, {
-      token: token.text,
-      target: 'field',
-      lineIndex,
-      span: token.span,
-    });
-    if (parsed) {
-      attributes.push(parsed);
-    }
-  }
-
-  return {
-    kind: 'field',
-    name: fieldName,
-    typeName,
-    ...ifDefined('typeNamespaceId', typeNamespaceId),
-    ...ifDefined('typeContractSpaceId', typeContractSpaceId),
-    ...ifDefined('typeConstructor', typeConstructor),
-    optional,
-    list,
-    attributes,
-    span: createTrimmedLineSpan(context, lineIndex),
-  };
-}
-
-function isQuoteEscaped(value: string, quoteIndex: number): boolean {
-  let backslashCount = 0;
-
-  for (let index = quoteIndex - 1; index >= 0 && value[index] === '\\'; index -= 1) {
-    backslashCount += 1;
-  }
-
-  return backslashCount % 2 === 1;
-}
-
-function splitTypeAndAttributes(value: string): {
-  readonly typeSource: string;
-  readonly attributeSource: string;
-  readonly attributeOffset: number;
-} {
-  let depthParen = 0;
-  let depthBracket = 0;
-  let depthBrace = 0;
-  let quote: '"' | "'" | null = null;
-
-  for (let index = 0; index < value.length; index += 1) {
-    const character = value[index] ?? '';
-    if (quote) {
-      if (character === quote && !isQuoteEscaped(value, index)) {
-        quote = null;
-      }
-      continue;
-    }
-
-    if (character === '"' || character === "'") {
-      quote = character;
-      continue;
-    }
-    if (character === '(') {
-      depthParen += 1;
-      continue;
-    }
-    if (character === ')') {
-      depthParen = Math.max(0, depthParen - 1);
-      continue;
-    }
-    if (character === '[') {
-      depthBracket += 1;
-      continue;
-    }
-    if (character === ']') {
-      depthBracket = Math.max(0, depthBracket - 1);
-      continue;
-    }
-    if (character === '{') {
-      depthBrace += 1;
-      continue;
-    }
-    if (character === '}') {
-      depthBrace = Math.max(0, depthBrace - 1);
-      continue;
-    }
-
-    if (character === '@' && depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
-      return {
-        typeSource: value.slice(0, index).trimEnd(),
-        attributeSource: value.slice(index),
-        attributeOffset: index,
-      };
-    }
-  }
-
-  return {
-    typeSource: value.trimEnd(),
-    attributeSource: '',
-    attributeOffset: value.length,
-  };
-}
-
-function parseAttributeToken(
-  context: ParserContext,
-  input: {
-    readonly token: string;
-    readonly target: PslAttributeTarget;
-    readonly lineIndex: number;
-    readonly span: PslSpan;
-  },
-): PslAttribute | undefined {
-  const expectsBlockPrefix = input.target === 'model' || input.target === 'enum';
-  const targetLabel = input.target === 'enum' ? 'Enum' : 'Model';
-  if (expectsBlockPrefix && !input.token.startsWith('@@')) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `${targetLabel} attribute "${input.token}" must use @@ prefix`,
-      span: input.span,
-    });
-    return undefined;
-  }
-  if (!expectsBlockPrefix && !input.token.startsWith('@')) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Attribute "${input.token}" must use @ prefix`,
-      span: input.span,
-    });
-    return undefined;
-  }
-  if (!expectsBlockPrefix && input.token.startsWith('@@')) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Attribute "${input.token}" is not valid in ${input.target} context`,
-      span: input.span,
-    });
-    return undefined;
-  }
-
-  const rawBody = expectsBlockPrefix ? input.token.slice(2) : input.token.slice(1);
-  const openParen = rawBody.indexOf('(');
-  const closeParen = rawBody.lastIndexOf(')');
-  const hasArgs = openParen >= 0 || closeParen >= 0;
-  if ((openParen >= 0 && closeParen === -1) || (openParen === -1 && closeParen >= 0)) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Invalid attribute syntax "${input.token}"`,
-      span: input.span,
-    });
-    return undefined;
-  }
-
-  const name = (openParen >= 0 ? rawBody.slice(0, openParen) : rawBody).trim();
-  if (!/^[A-Za-z_][A-Za-z0-9_-]*(\.[A-Za-z_][A-Za-z0-9_-]*)*$/.test(name)) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Invalid attribute name "${name || input.token}"`,
-      span: input.span,
-    });
-    return undefined;
-  }
-
-  let args: readonly PslAttributeArgument[] = [];
-  if (hasArgs && openParen >= 0 && closeParen >= openParen) {
-    if (closeParen !== rawBody.length - 1) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-        message: `Invalid trailing syntax in attribute "${input.token}"`,
-        span: input.span,
-      });
-      return undefined;
-    }
-    const argsRaw = rawBody.slice(openParen + 1, closeParen);
-    const parsedArgs = parseArgumentList(context, {
-      argsRaw,
-      argsOffset: input.span.start.column - 1 + (expectsBlockPrefix ? 2 : 1) + openParen + 1,
-      lineIndex: input.lineIndex,
-      token: input.token,
-      span: input.span,
-      invalidCode: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      invalidEmptyArgumentMessage: `Invalid empty argument in attribute "${input.token}"`,
-      invalidNamedArgumentMessage: (part) => `Invalid named argument syntax "${part}"`,
-    });
-    if (!parsedArgs) {
-      return undefined;
-    }
-    args = parsedArgs;
-  }
-
-  return {
-    kind: 'attribute',
-    target: input.target,
-    name,
-    args,
-    span: input.span,
-  };
-}
-
-function parseArgumentList(
-  context: ParserContext,
-  input: {
-    readonly argsRaw: string;
-    readonly argsOffset: number;
-    readonly lineIndex: number;
-    readonly token: string;
-    readonly span: PslSpan;
-    readonly invalidCode: PslDiagnosticCode;
-    readonly invalidEmptyArgumentMessage: string;
-    readonly invalidNamedArgumentMessage: (part: string) => string;
-  },
-): readonly PslAttributeArgument[] | undefined {
-  const trimmed = input.argsRaw.trim();
-  if (trimmed.length === 0) {
-    return [];
-  }
-
-  const parts = splitTopLevelSegments(input.argsRaw, ',');
-  const args: PslAttributeArgument[] = [];
-
-  for (const part of parts) {
-    const original = part.value;
-    const trimmedPart = original.trim();
-    if (trimmedPart.length === 0) {
-      pushDiagnostic(context, {
-        code: input.invalidCode,
-        message: input.invalidEmptyArgumentMessage,
-        span: input.span,
-      });
-      return undefined;
-    }
-
-    const leadingWhitespace = original.length - original.trimStart().length;
-    const partStart = input.argsOffset + part.start + leadingWhitespace;
-    const partEnd = partStart + trimmedPart.length;
-    const partSpan = createInlineSpan(context, input.lineIndex, partStart, partEnd);
-
-    const namedSplit = splitTopLevelSegments(trimmedPart, ':');
-    if (namedSplit.length > 1) {
-      const first = namedSplit[0];
-      if (!first) {
-        pushDiagnostic(context, {
-          code: input.invalidCode,
-          message: input.invalidNamedArgumentMessage(trimmedPart),
-          span: partSpan,
-        });
-        return undefined;
-      }
-      const name = first.value.trim();
-      const rawValue = trimmedPart.slice(first.end + 1).trim();
-      if (!name || rawValue.length === 0) {
-        pushDiagnostic(context, {
-          code: input.invalidCode,
-          message: input.invalidNamedArgumentMessage(trimmedPart),
-          span: partSpan,
-        });
-        return undefined;
-      }
-      args.push({
-        kind: 'named',
-        name,
-        value: normalizeAttributeArgumentValue(rawValue),
-        span: partSpan,
-      });
-      continue;
-    }
-
-    args.push({
-      kind: 'positional',
-      value: normalizeAttributeArgumentValue(trimmedPart),
-      span: partSpan,
-    });
-  }
-
-  return args;
-}
-
-function normalizeAttributeArgumentValue(value: string): string {
-  return value.trim();
-}
-
-function findBlockBounds(context: ParserContext, startLine: number): BlockBounds {
-  let depth = 0;
-
-  for (let lineIndex = startLine; lineIndex < context.lines.length; lineIndex += 1) {
-    const line = stripInlineComment(context.lines[lineIndex] ?? '');
-    let quote: '"' | "'" | null = null;
-    for (let index = 0; index < line.length; index += 1) {
-      const character = line[index] ?? '';
-      if (quote) {
-        if (character === quote && !isQuoteEscaped(line, index)) {
-          quote = null;
-        }
-        continue;
-      }
-
-      if (character === '"' || character === "'") {
-        quote = character;
-        continue;
-      }
-
-      if (character === '{') {
-        depth += 1;
-      }
-      if (character === '}') {
-        depth -= 1;
-        if (depth === 0) {
-          return { startLine, endLine: lineIndex, closed: true };
-        }
-      }
-    }
-  }
-
-  pushDiagnostic(context, {
-    code: 'PSL_UNTERMINATED_BLOCK',
-    message: 'Unterminated block declaration',
-    span: createTrimmedLineSpan(context, startLine),
-  });
-  return {
-    startLine,
-    endLine: context.lines.length - 1,
-    closed: false,
-  };
-}
-
-interface TopLevelSegment {
-  readonly value: string;
-  readonly start: number;
-  readonly end: number;
-}
-
-function splitTopLevelSegments(value: string, separator: ',' | ':'): TopLevelSegment[] {
-  const parts: TopLevelSegment[] = [];
-  let depthParen = 0;
-  let depthBracket = 0;
-  let depthBrace = 0;
-  let quote: '"' | "'" | null = null;
-  let start = 0;
-
-  for (let index = 0; index < value.length; index += 1) {
-    const character = value[index] ?? '';
-    if (quote) {
-      if (character === quote && !isQuoteEscaped(value, index)) {
-        quote = null;
-      }
-      continue;
-    }
-
-    if (character === '"' || character === "'") {
-      quote = character;
-      continue;
-    }
-
-    if (character === '(') {
-      depthParen += 1;
-      continue;
-    }
-    if (character === ')') {
-      depthParen = Math.max(0, depthParen - 1);
-      continue;
-    }
-    if (character === '[') {
-      depthBracket += 1;
-      continue;
-    }
-    if (character === ']') {
-      depthBracket = Math.max(0, depthBracket - 1);
-      continue;
-    }
-    if (character === '{') {
-      depthBrace += 1;
-      continue;
-    }
-    if (character === '}') {
-      depthBrace = Math.max(0, depthBrace - 1);
-      continue;
-    }
-
-    if (character === separator && depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
-      parts.push({
-        value: value.slice(start, index),
-        start,
-        end: index,
-      });
-      start = index + 1;
-    }
-  }
-
-  parts.push({
-    value: value.slice(start),
-    start,
-    end: value.length,
-  });
-  return parts;
-}
-
-function extractAttributeTokensWithSpans(
-  context: ParserContext,
-  lineIndex: number,
-  value: string,
-  startColumn: number,
-): { readonly ok: boolean; readonly tokens: readonly { text: string; span: PslSpan }[] } {
-  const tokens: { text: string; span: PslSpan }[] = [];
-  let index = 0;
-  while (index < value.length) {
-    while (index < value.length && /\s/.test(value[index] ?? '')) {
-      index += 1;
-    }
-    if (index >= value.length) {
-      break;
-    }
-
-    if (value[index] !== '@') {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-        message: `Invalid attribute syntax "${value.trim()}"`,
-        span: createInlineSpan(context, lineIndex, startColumn + index, startColumn + value.length),
-      });
-      return { ok: false, tokens };
-    }
-
-    const start = index;
-    index += 1;
-    if (value[index] === '@') {
-      index += 1;
-    }
-
-    const nameStart = index;
-    while (index < value.length && /[A-Za-z0-9_.-]/.test(value[index] ?? '')) {
-      index += 1;
-    }
-
-    if (index === nameStart) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-        message: `Invalid attribute syntax "${value.slice(start).trim()}"`,
-        span: createInlineSpan(context, lineIndex, startColumn + start, startColumn + value.length),
-      });
-      return { ok: false, tokens };
-    }
-
-    if (value[index] === '(') {
-      let depth = 0;
-      let quote: '"' | "'" | null = null;
-      while (index < value.length) {
-        const char = value[index] ?? '';
-        if (quote) {
-          if (char === quote && !isQuoteEscaped(value, index)) {
-            quote = null;
-          }
-          index += 1;
-          continue;
-        }
-
-        if (char === '"' || char === "'") {
-          quote = char;
-          index += 1;
-          continue;
-        }
-
-        if (char === '(') {
-          depth += 1;
-        } else if (char === ')') {
-          depth -= 1;
-          if (depth === 0) {
-            index += 1;
-            break;
-          }
-        }
-        index += 1;
-      }
-      if (depth !== 0) {
-        pushDiagnostic(context, {
-          code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-          message: `Unterminated attribute argument list in "${value.slice(start).trim()}"`,
-          span: createInlineSpan(
-            context,
-            lineIndex,
-            startColumn + start,
-            startColumn + value.length,
-          ),
-        });
-        return { ok: false, tokens };
-      }
-    }
-
-    const tokenText = value.slice(start, index).trim();
-    tokens.push({
-      text: tokenText,
-      span: createInlineSpan(context, lineIndex, startColumn + start, startColumn + index),
-    });
-
-    while (index < value.length && /\s/.test(value[index] ?? '')) {
-      index += 1;
-    }
-
-    if (index < value.length && value[index] !== '@') {
-      break;
-    }
-  }
-
-  if (index < value.length && value[index] !== '@') {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Invalid attribute syntax "${value.trim()}"`,
-      span: createInlineSpan(context, lineIndex, startColumn + index, startColumn + value.length),
-    });
-    return { ok: false, tokens };
-  }
-
-  return { ok: true, tokens };
-}
-
-function stripInlineComment(line: string): string {
-  let quote: '"' | "'" | null = null;
-  for (let index = 0; index < line.length - 1; index += 1) {
-    const current = line[index] ?? '';
-    const next = line[index + 1] ?? '';
-
-    if (quote) {
-      if (current === quote && !isQuoteEscaped(line, index)) {
-        quote = null;
-      }
-      continue;
-    }
-
-    if (current === '"' || current === "'") {
-      quote = current;
-      continue;
-    }
-
-    if (current === '/' && next === '/') {
-      return line.slice(0, index);
-    }
-  }
-
-  return line;
-}
-
-function computeLineOffsets(schema: string): number[] {
-  const offsets = [0];
-  for (let index = 0; index < schema.length; index += 1) {
-    if (schema[index] === '\n') {
-      offsets.push(index + 1);
-    }
-  }
-  return offsets;
-}
-
-function firstNonWhitespaceColumn(line: string): number {
-  const first = line.search(/\S/);
-  return first === -1 ? 0 : first;
-}
-
-function createInlineSpan(
-  context: ParserContext,
-  lineIndex: number,
-  startColumn: number,
-  endColumn: number,
-): PslSpan {
-  return {
-    start: createPosition(context, lineIndex, startColumn),
-    end: createPosition(context, lineIndex, endColumn),
-  };
-}
-
-function createTrimmedLineSpan(context: ParserContext, lineIndex: number): PslSpan {
-  const line = context.lines[lineIndex] ?? '';
-  const startColumn = firstNonWhitespaceColumn(line);
-  return {
-    start: createPosition(context, lineIndex, startColumn),
-    end: createPosition(context, lineIndex, line.length),
-  };
-}
-
-function createLineRangeSpan(context: ParserContext, startLine: number, endLine: number): PslSpan {
-  const startLineText = context.lines[startLine] ?? '';
-  const endLineText = context.lines[endLine] ?? '';
-  const startColumn = firstNonWhitespaceColumn(startLineText);
-  return {
-    start: createPosition(context, startLine, startColumn),
-    end: createPosition(context, endLine, endLineText.length),
-  };
-}
-
-function createPosition(
-  context: ParserContext,
-  lineIndex: number,
-  columnIndex: number,
-): PslPosition {
-  const clampedLineIndex = Math.max(0, Math.min(lineIndex, context.lineOffsets.length - 1));
-  const lineText = context.lines[clampedLineIndex] ?? '';
-  const clampedColumnIndex = Math.max(0, Math.min(columnIndex, lineText.length));
-  return {
-    offset: (context.lineOffsets[clampedLineIndex] ?? 0) + clampedColumnIndex,
-    line: clampedLineIndex + 1,
-    column: clampedColumnIndex + 1,
-  };
-}
-
-function pushDiagnostic(
-  context: ParserContext,
-  diagnostic: Omit<PslDiagnostic, 'sourceId'> & { readonly code: PslDiagnosticCode },
-): void {
-  context.diagnostics.push({
-    ...diagnostic,
-    sourceId: context.sourceId,
-  });
-}
-
-function lookupExtensionBlockDescriptor(
-  namespace: AuthoringPslBlockDescriptorNamespace,
-  keyword: string,
-): AuthoringPslBlockDescriptor | undefined {
-  if (!Object.hasOwn(namespace, keyword)) {
-    return undefined;
-  }
-  const value = namespace[keyword];
-  return isAuthoringPslBlockDescriptor(value) ? value : undefined;
-}
-
-/**
- * Reads an extension block body generically, driven by the descriptor's
- * `parameters` map. Each `key = <rhs>` line in the body is matched against
- * a declared parameter and the RHS is captured per the parameter's kind:
- *
- * - `ref`    → the bareword identifier token (`PslExtensionBlockParamRef`)
- * - `value`  → the raw RHS text verbatim (`PslExtensionBlockParamScalarValue`)
- * - `option` → the chosen bareword token (`PslExtensionBlockParamOption`)
- * - `list`   → bracketed `[a, b, …]` list, each element captured per `of`
- *   (`PslExtensionBlockParamList`)
- *
- * No validation runs here (unknown key, missing required, codec acceptance,
- * option-in-set, ref resolution). A body line that is not `key = value`
- * shaped emits a `PSL_INVALID_EXTENSION_BLOCK_MEMBER` parse diagnostic.
- */
-function parseExtensionBlock(
-  context: ParserContext,
-  descriptor: AuthoringPslBlockDescriptor,
-  blockName: string,
-  keywordLineIndex: number,
-  bounds: BlockBounds,
-): PslExtensionBlock {
-  const parameters: Record<string, PslExtensionBlockParamValue> = {};
-
-  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
-    const raw = context.lines[lineIndex] ?? '';
-    const line = stripInlineComment(raw).trim();
-    if (line.length === 0) {
-      continue;
-    }
-
-    const assignMatch = line.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
-    if (!assignMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_EXTENSION_BLOCK_MEMBER',
-        message: `Invalid extension block body line "${line}"; expected "key = value"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      continue;
-    }
-
-    const key = assignMatch[1] ?? '';
-    const rhsRaw = (assignMatch[2] ?? '').trim();
-    const paramDescriptor = descriptor.parameters[key];
-
-    if (paramDescriptor === undefined) {
-      // Unknown parameter — captured as a raw value; the generic validator reports this.
-      parameters[key] = {
-        kind: 'value',
-        raw: rhsRaw,
-        span: createTrimmedLineSpan(context, lineIndex),
-      };
-      continue;
-    }
-
-    const captured = captureParamRhs(context, lineIndex, rhsRaw, paramDescriptor);
-    if (captured !== undefined) {
-      parameters[key] = captured;
-    }
-  }
-
-  return {
-    kind: descriptor.discriminator,
-    name: blockName,
-    parameters,
-    span: createLineRangeSpan(context, keywordLineIndex, bounds.endLine),
-  };
-}
-
-/**
- * Captures a single parameter RHS string according to the declared parameter
- * kind. Returns `undefined` and pushes a diagnostic only if the syntax is
- * genuinely malformed (e.g. a `list` with no opening bracket). Value
- * acceptance (codec, option-in-set, ref resolution) is handled by the validator.
- */
-function captureParamRhs(
-  context: ParserContext,
-  lineIndex: number,
-  rhs: string,
-  param: AuthoringPslBlockDescriptor['parameters'][string],
-): PslExtensionBlockParamValue | undefined {
-  const span = createTrimmedLineSpan(context, lineIndex);
-
-  switch (param.kind) {
-    case 'ref': {
-      return { kind: 'ref', identifier: rhs, span };
-    }
-    case 'value': {
-      return { kind: 'value', raw: rhs, span };
-    }
-    case 'option': {
-      return { kind: 'option', token: rhs, span };
-    }
-    case 'list': {
-      if (!rhs.startsWith('[') || !rhs.endsWith(']')) {
-        pushDiagnostic(context, {
-          code: 'PSL_INVALID_EXTENSION_BLOCK_MEMBER',
-          message: `Expected a bracketed list "[…]" for list parameter, got "${rhs}"`,
-          span,
-        });
-        return undefined;
-      }
-      const inner = rhs.slice(1, -1).trim();
-      const items: PslExtensionBlockParamValue[] = [];
-      if (inner.length > 0) {
-        const segments = splitTopLevelSegments(inner, ',');
-        for (const segment of segments) {
-          const itemRhs = segment.value.trim();
-          if (itemRhs.length === 0) {
-            continue;
-          }
-          const item = captureParamRhs(context, lineIndex, itemRhs, param.of);
-          if (item !== undefined) {
-            items.push(item);
-          }
-        }
-      }
-      return { kind: 'list', items, span };
-    }
-  }
-}