Cluster detail
reqlan rq/language
Ideas located under folder reqlan rq/language.
folder
64 ideas
6 files
| Idea | File | Status | Summary | Katz |
|---|---|---|---|---|
| attribute_configuration | reqlan rq/language/attributes.rq | The extension should be largely unopinionated about attributes, allowing users to extend as they see fit. attributes should be as slim as possible to allow for minimised bloat. | 0.049 | |
| anonymous_imports_allowed | reqlan rq/language/imports.rq | done | A quoted path plus idea — for example `["../ontology.rq".attribute]` — opens that file as an ideaset. Every idea in the target file is in scope for that reference. A from-import or qualified import of the same path only binds the listed names for bare `[name]` references. It must not hide other ideas from a quoted-path reference. | 0.073 |
| configuration_import_root_alias | reqlan rq/language/imports.rq | An import path may start with an alias string, then `/`, then a relative path under that alias's import-root directory. Default alias string: `@`, written as `@/` plus a path relative to the import root. Default import-root directory: the workspace folder that contains the `.rq` file ( not the document directory ). The path after `/` is joined to that alias's import-root directory; the alias itself must be followed by `/` ( e. g. `@reqs` is not aliased ). Alias strings and import-root directories are configured as [configuration.configuration_import_roots] in the applying `.reqlan/config.json` from [configuration.configuration_location]. A configured relative `root` resolves against the base root ( parent of `.reqlan` ); an omitted `root` keeps the workspace-folder default. When several configured aliases could match a path, the longest alias wins. Related path forms: [import_paths], ["../extension/language/comment-references/functional-code-comment-references.rq".comment_reference_import_root_alias]. Completion: ["../extension/language/syntax/features-syntax.rq".code_completion]. File references and the language server use the same locate rule as ["../core_analysis/check.rq".check]: load `importRoots` from the applying `.reqlan/config.json` for the source file ( [configuration.configuration_location] ), then `resolve_rq_path` and join the workspace when the result is relative — including paths with spaces such as `["@/my file.ts"]`. | 0.296 | |
| idea_path_filter | reqlan rq/language/imports.rq | done | Shared path-filter helper for [wildcard_references_webview] search seeding. Glob or substring match against workspace-relative path and file URI; leading `./` / `../` segments are stripped for relative filters; `**/` is implied when the filter has glob meta but is not already rooted with `**/`. Used only as a hard AND after fuzzy ranking — it never replaces the idea-name query. | 0.078 |
| import_error_recovery | reqlan rq/language/imports.rq | A malformed import must not invalidate the rest of the file. Recoverable invalid `from` shapes parse as local import nodes with a line-level diagnostic: - `from "path" as alias` ( mistaken namespace form ) — suggest `import "path" as alias` or `from "path" import <idea>` - bare `from "path"` — require the `import <idea>` clause - `from` without a quoted path — consume the remainder of the line as an invalid import Later imports and top-level ideas continue to parse and link normally. Same recovery posture for nameless top-level braces: ["./syntax.rq".no_name_idea_safe_warning]. If lex / parse never completes, see ["./parser_lexer.rq".parse_budget_timeout]. | 0.058 | |
| import_from | reqlan rq/language/imports.rq | From-import syntax uses from, a quoted path, import, and an idea name. From-import may list more than one idea. Separate the names with commas. From-import may include an alias using as. The parser records a span for the path, each idea name, and each alias. Each of those tokens is its own document link. The path links to the file. An idea name links to that declaration. An alias links to the same declaration. When the alias contains the imported idea name, Ctrl + click on a bracket reference still treats the whole alias as one link. See ["../extension/language/syntax/features-syntax-highlighting.rq".aliased_from_import_ctrl_click]. The language server uses the parser spans: ["../extension/language/support/language-server-rust.rq".language_server_rust]. | 0.220 | |
| import_keywords | reqlan rq/language/imports.rq | The keywords import, from, and as are reserved for import statements. Import keywords may also appear as ordinary words in idea body text when not at statement start. | 0.047 | |
| import_namespace | reqlan rq/language/imports.rq | Namespace import syntax uses import and a quoted path. Namespace import may include an alias using as. A bracket reference to the alias alone — for example `[context_model]` — opens the imported file and links only the alias name, like an ideaset namespace. Qualified references through the alias — for example `[context_model.builder]` — resolve ideas from the imported module. A qualified reference may also name an import alias bound in that module. Example: `[core_arch.analysis_runtime]` when `analysis_runtime` is an import alias in the imported file. That name is not an idea. Check does not report it as a missing idea ( ["../core_analysis/check.rq".check_qualified_missing_idea] ). A from-import of that alias is still a missing idea. | 0.179 | |
| import_paths | reqlan rq/language/imports.rq | Import path strings may use relative paths such as. / exampleimport. rq. Import path strings may use paths containing folders. The import target may be a file or a folder; see ["../extension/language/support/features-imports.rq".import_folder_targets]. Import path strings may use remote urls such as https://company.com/reqs/style.rq. Import path strings may use an import-root alias shorthand such as `@/path/relative/to/import/root`; see [configuration_import_root_alias]. Path forms apply to from-import, namespace import, qualified import, file references, and qualified comment references ( `rq:["@/path".idea]` ); see [import_from], [import_namespace], [import_qualified], ["./syntax.rq".reference_file], and ["../extension/language/comment-references/functional-code-comment-references.rq".comment_reference_import_root_alias]. Editor completion for path strings is covered by ["../extension/language/syntax/features-syntax.rq".code_completion]. | 0.155 | |
| import_qualified | reqlan rq/language/imports.rq | Qualified import syntax uses import, a quoted path, a dot, an ideaset name, a dot, and an idea name. Qualified import may include an alias using as. | 0.126 | |
| import_tokenisation | reqlan rq/language/imports.rq | if an import is given an alias, then the base name is still available as a variable name and should not cause a conflict. Only the alias binds in the importing file; the imported idea's base name may be reused for a local idea. e. g. The same rule applies to qualified imports with `as`. Unaliased imports still bind the idea name and conflict with a local idea of that name. Related: ["../extension/language/syntax/features-syntax.rq".sensible_alias_support]. | 0.053 | |
| wildcard_references | reqlan rq/language/imports.rq | done | Qualified path + idea-pattern references match multiple ideas across files. Surface forms: bracket `[…]` and wikilink `[[…]]` ( same `WildcardReference` target ). Path is a quoted string that may include shell-style globs ( `*`, `**`, `?` ) and `@/` import-root aliases ( [configuration_import_root_alias] ). Relative globs resolve against the defining document directory; `.` / `..` segments are collapsed before matching. Idea pattern is an unquoted `WILDCARD_NAME` that must contain at least one `*` or `?` Exact quoted-path plus idea stays ["./syntax.rq".reference_qualified]. Matching uses anchored globs ( not full JS regex ): path `*` is one segment, `**` crosses segments; idea `*` / `?` match within the idea name. Zero matches produce a warning diagnostic. One match also produces a warning — a wildcard is for many ideas; use a concrete ["./syntax.rq".reference_qualified] when only one idea matches ( ["../core_analysis/check.rq".check_wildcard_one] ). Path segment `/**/` must not be lexed as an empty block comment — see ["./syntax.rq".comments]. Lexer note: `ID` is a prefix of many wildcard names ( `import_` vs `import_*` ); the token builder sets `ID.LONGER_ALT = WILDCARD_NAME` so `import_*` is one token. Body prose `*` tokens are accepted via `WILDCARD_NAME` in PlainText so ordinary `*` characters still parse. Without that longer-alt, a live wildcard inside a block body can fail Idea recovery and leave later top-level ideas unindexed ( soft mtime sync will not rebuild until the `.rq` file changes ). Navigation does not emit N LocationLinks. A document-link click opens `reqlan.openWildcardReference` with `{ pathPattern, ideaPattern, fromUri }` ( see [wildcard_references_webview] ). Go-to-definition does not open that panel. Indexing fans out per ["../indexer/indexer.rq".wildcard_reference_edges] ( owned under ["../indexer/indexer.rq".index] ): native extract writes one `wildcard_reference` edge per catalog match; empty catalog / zero matches → one unresolved edge of that kind labeled with the pattern text. ["../core_analysis/check.rq".check] handles 0 - match and 1 - match fan-out through ["../core_analysis/check.rq".check_wildcard_zero] and ["../core_analysis/check.rq".check_wildcard_one] ( ["../core_analysis/check.rq".check_wildcard_sparse] ). Ideas Summary graph toggles those edges via ["../extension/workspace-summary/ideas_summary/graphical_graph.rq".wildcard_refs_toggle]. The server can answer `reqlan/wildcardReferenceAt`. Go-to-definition does not call it. Related: ["./syntax.rq".reference_embedding], ["./syntax.rq".reference_brackets], ["./syntax.rq".reference_wikilink], ["../indexer/indexer.rq".wildcard_reference_edges], ["../core_analysis/check.rq".check_wildcard_sparse], ["../core_analysis/check.rq".check_wildcard_zero], ["../core_analysis/check.rq".check_wildcard_one]. Illustrative forms ( fenced so this file does not embed live wildcards ): | 0.486 |
| wildcard_references_webview | reqlan rq/language/imports.rq | done | A click on the command document link for a [wildcard_references] target runs `reqlan.openWildcardReference` and opens a dedicated **wildcard matches** webview ( beside the editor ) that lists: - Stats: matching idea count, distinct file count, and @ status breakdown - Requirements: each matching idea with name, status, path, and summary ( click opens the idea ) - Files: each matching file with idea count ( click opens the file ) Secondary action **Open in Search** seeds the activity-bar ["../extension/local-context/activitybar-panels/search.rq".search_pane_seed] via `focusIdeaSearch` with: - `query`: idea pattern with glob meta softened for fuzzy search ( `import_*` → `import` ) - `pathFilter`: the path glob as a hard AND filter ( [idea_path_filter] ) Payload builder: `buildWildcardMatchesPayload` filters the index catalog by idea glob + path filter. Protocol for the matches panel is inline host ↔ webview ( `init` / `openIdea` / `openFile` / `openSearch` ). The document-link target is the command URI. Go-to-definition does not open the panel. Highlighting of the source reference must stay link-styled — see ["../extension/language/syntax/features-syntax.rq".syntax_highlighting] and ["../extension/language/syntax/features-syntax-highlighting.rq".wildcard_reference_highlighting]. | 0.199 |
| lexer_bridge_to_syntax | reqlan rq/language/parser_lexer.rq | The context-sensitive token builder is what makes [block_idea] and prose braces coexist: structural `{` / `}` are only those that open or close ideas, while [nested_curly_braces] stay body text. [context_sensitive_lexer_scaling] is the performance contract for that bridge; [code_snippets] is the opacity contract so fence interiors never feed the brace timeline. Index-path Rust port: ["../core_analysis/rust_port.rq".lexer_rust] / ["../core_analysis/rust_port.rq".parser_rust]. | 0.077 | |
| parse_budget_timeout | reqlan rq/language/parser_lexer.rq | done | Lexing, parsing, or a parse subprocess for a single `.rq` file must finish within `parseBudgetMs` from ["../../packages/analytical/src/core/defaults.json"]. If it cannot, do not hang the language server or block the rest of the workspace. Surface both a warning ( budget exceeded; semantic features may be incomplete ) and an error ( file left unloaded ) on that document, then continue with other files. Happy path stays in-process ( sync ) for typical file sizes so edits and workspace load stay fast. Killable worker enforcement is used when the input is large, a file previously hit the budget ( sticky escalate ), or a caller forces the worker path; sync throws still become the same incomplete result shape. The open buffer stores that result as an empty model plus diagnostics ( ["../extension/language/support/open-file-sequencing.rq".ast_lifecycle] ). | 0.197 |
| recovery_vs_budget | reqlan rq/language/parser_lexer.rq | [no_name_idea_safe_warning] and [import_error_recovery] keep a *finished* parse usable after local mistakes. They do not help when lex / parse never returns — that failure mode is [parse_budget_timeout]. Workspace load still isolates per-document throws so one bad file cannot abort LSP init; the budget turns non-termination into the same “ leave this file unloaded ” outcome, with diagnostics. | 0.069 | |
| closing_nested_curly_braces | reqlan rq/language/syntax-edge-cases.rq | if, for some reason, there is a prose block containing only closing curly braces, they should be escaped and allowed \ } like this. | 0.040 | |
| context_sensitive_lexer_scaling | reqlan rq/language/syntax-edge-cases.rq | done | Context-sensitive token classification for structural / prose braces and top-level import keywords must remain linear in document size. The lexer records brace-depth changes sparsely ( not per-character tables ) and looks them up in log time while tokenising, so workspace language-server initialization and editor re-lexes stay bounded. Code fences are skipped during the brace scan so example braces cannot inflate work or desync depth. Bounded work still assumes the lexer / parser *returns*; unbounded hangs are cut by ["./parser_lexer.rq".parse_budget_timeout]. | 0.097 |
| fencing_comments | reqlan rq/language/syntax-edge-cases.rq | done | A complete same-line fence keeps `//` and `/*` as prose, not comments. Closed double quotes: " / / this line " contains no comment. Closed backticks: `//this line` contains no comment. Closed backticks with a glob: `@reqlan/*` does not open a block comment. An unclosed backtick is not a fence, so this line ` An unclosed quote is not a fence, so as does " The Langium lexer, the Rust lexer, comment scanners, and TextMate must use this rule. Related: ["./syntax.rq".comments], ["./syntax.rq".inline_code], ["./syntax.rq".naked_strings_in_body], ["../core_analysis/rust_port.rq".comment_span_align]. | 0.078 |
| nested_curly_braces | reqlan rq/language/syntax-edge-cases.rq | if there is a prose block containing curly braces, { such as this one } they should be treated as part of the prose. Matching braces that end a line — including adjacent pairs like { { SITE_URL } } — stay in the body; they must not close the enclosing idea. A lone `}` on its own line still closes the structural block so an unbalanced prose `{` cannot swallow the idea closer. | 0.108 | |
| one_liner_curly_brace_context | reqlan rq/language/syntax-edge-cases.rq | this should { be acceptable } as well | 0.050 | |
| attribute_forms | reqlan rq/language/syntax.rq | A bare attribute name after @ denotes a true flag or render keyword. A negated flag uses a trailing bang after the attribute name. A valued attribute uses a space after the attribute name followed by a value. A colon after the attribute name is optional legacy syntax and is not part of the value. Common attributes include plan, status, priority, criticality, confirmation, owner, log, tags, and references with the @ prefix. Any custom attribute name is allowed. | 0.049 | |
| attribute_location | reqlan rq/language/syntax.rq | Marked attributes must be at the start of a line. @ this_is_not_an_attribute | 0.049 | |
| attribute_marker | reqlan rq/language/syntax.rq | Attributes are introduced with the @ prefix. Attribute names follow identifier rules. | 0.066 | |
| attribute_namespacing | reqlan rq/language/syntax.rq | done | A bracket link `[idea.attribute]` targets one attribute of that idea. The first name is the idea name. The second name is the attribute name. The grammar types that name as an attribute or an idea declaration. `[attribute_namespacing.example]` targets the `example` attribute of this idea. The form `[ideaset.member]` still targets an ideaset member. See [references_to_subidea]. The editor opens the attribute when the first name is an idea. The editor reports an error when that idea has no attribute with the second name. The link target is only that attribute on that idea. HTML export uses the same link form. The export link opens that attribute on the idea page. See [attribute_namespacing.example]. Related: [reference_brackets], [attribute_marker], ["../core_analysis/html_export.rq".html_export_internal_links]. | 0.129 |
| attribute_values | reqlan rq/language/syntax.rq | Attribute values may be unstructured scalar text on the same line. Attribute values may be block values in curly braces. Attribute values may be list values in parentheses. | 0.049 | |
| block_idea | reqlan rq/language/syntax.rq | A block idea is a name followed by curly braces that contain a body and optional attributes. The opening `{` may share the line with the closing `}` ( `name {}`, `name {hello}` ). The opening `{` may also sit at the end of the name line, with the closer on a later line. `{` starts a block only when it is immediately after the name ( optional spaces ). If other text is between the name and `{`, the line is a [simple_idea] and the braces are body text. The first unstructured text in an idea body is the main description when no other body attribute is marked. | 0.099 | |
| code_snippets | reqlan rq/language/syntax.rq | Idea bodies and block attribute values may embed fenced code blocks delimited by triple backticks. An opening fence is three backticks as the first non-whitespace characters on a line, optionally followed by a language tag such as python or rq. A closing fence is three backticks as the first non-whitespace characters on a line. Three backticks in the middle of a line are prose. They do not open a fence. Everything between the fences is literal opaque text — it is not parsed as reqlan syntax. Keywords, imports, attributes, braces, and quotes inside a fence are inert for the parser and may be shown as examples without parse errors. Fenced blocks may span multiple lines and preserve their inner content verbatim. Brace-depth tracking must skip fence interiors so example braces cannot desync surrounding structure ( [no_name_idea_safe_warning] ). Related: ["../core_analysis/rust_port.rq".comment_span_align]. | 0.113 | |
| comment_reference | reqlan rq/language/syntax.rq | done | Reqlan references may appear in line comments of arbitrary source files. Comment reference syntax is `rq:[idea]` or `rq:["path".idea]` ( quoted path, optional extra qualification ). Qualified paths use the same path forms as imports, including import-root aliases such as `@/` — ["imports.rq".configuration_import_root_alias], ["../extension/language/comment-references/functional-code-comment-references.rq".comment_reference_import_root_alias]. Discovery skips quoted strings, including Rust raw strings ( `r#"…"#`, `r##"…"##`, `br#"…"#` ), so `rq:[…]` text in a string is not a live comment. Editor language coverage is a blocklist, not an allowlist: ["../extension/language/comment-references/functional-code-comment-references.rq".comment_reference_language_blocklist]. Indexed as `comment_link` by ["../indexer/indexer.rq".index_code_files]. Unresolved targets: [comment_reference_resolution_error]. Indexer listing: ["../core_analysis/core.rq".test_references]. Refactors: ["../extension/mutation/refactor_support.rq".comment_reference_refactor_support]. | 0.365 |
| comment_reference_ignore | reqlan rq/language/syntax.rq | done | Comment reference ignore syntax uses `//rq-ignore-error`. Comment reference ignore suppresses diagnostics on the immediately following line. The language server and the CLI use the same core scanner [rq_ignore]. | 0.511 |
| comment_reference_resolution_error | reqlan rq/language/syntax.rq | done | If a comment reference cannot be resolved, show it as an error diagnostic. Do not create a document link to a missing file ( that underline then raises a generic cannot-find-file editor error ). Related: [comment_reference], [comment_reference_ignore], ["../reference_types.rq".comment_reference], ["../extension/language/comment-references/functional-code-comment-references.rq".references_in_functional_code_comments]. | 0.151 |
| comments | reqlan rq/language/syntax.rq | done | Line comments use `//` through end of line ( hidden `SL_COMMENT` ). Block comments use `/* … */` and may span multiple lines ( hidden `ML_COMMENT` ). Meta comments on the same line after content are allowed ( `keep this // meta` ). Comments must not open inside a string / reference-string context: - Naked body quotes ( ["naked_strings_in_body"] ): a quoted slash-slash that is not a comment, quoted urls, `"../mod/**/*.rq"`. - Reference / import `STRING` paths ( `["…"]`, `from "…" import …` ) — the lexer consumes the whole quoted path as one `STRING`, so neither `//` nor `/*` inside the quotes starts a comment. Example: a file reference whose path text contains slash-slash, `["../extension/**/*.rq".*webview*]`. - URL / path-segment guard: `//` immediately after `:` or `/` is not a line comment. Same-line fences: ["./syntax-edge-cases.rq".fencing_comments] — complete `"…"`, `'…'`, and ` ` ` … ` ` ` spans keep ` Unclosed quote or backtick openers are not fences, so `//` after them is a comment. Comment-range identity across lexer, scanner, and TextMate: ["../core_analysis/rust_port.rq".comment_span_align]. Multiline / glob clash: the empty block form `/**/` is **not** a comment — it is the recursive glob segment used in paths such as `../mod/**/*.rq`. A real block comment needs a non-empty body ( `/* note */`, `/*\n note\n*/` ). The token builder rejects length-4 `/**/` matches; comment-span scanners skip the same sequence so embedded `rq:[…]` discovery stays aligned. Related: [comment_reference_ignore], [string_literals], ["./imports.rq".wildcard_references], ["../core_analysis/rust_port.rq".comment_span_align]. | 0.145 |
| dash-or_undersore_delimited-idea | reqlan rq/language/syntax.rq | it should be possible to use dash or underscore delimited idea names. | 0.040 | |
| empty_attribute | reqlan rq/language/syntax.rq | A line that contains only @ is insignificant whitespace. Spaces or tabs may precede that @. Spaces or tabs may follow that @. The lexer consumes that @ as hidden whitespace. The parser does not build an attribute for that line. That line does not cause a parser error. That line does not cause a lexer error. That line does not cause a tokenizer error. That line does not cause an extension error. A flag keeps the form @ name. A negated flag keeps the form @ name!. A valued attribute keeps its value after the name. A syntax error on a different line is still reported. | 0.040 | |
| example_ideaset | reqlan rq/language/syntax.rq | Ideaset (example_ideaset) | 0.062 | |
| file_layout | reqlan rq/language/syntax.rq | incomplete | A file begins with zero or more import statements, followed by top-level ideas and ideasets. The file forms an implicit ideaset; its name may default to the filename without the suffix. Front matter syntax is not yet specified. | 0.070 |
| file_suffix | reqlan rq/language/syntax.rq | Reqlan requirement documents use the. rq file suffix. | 0.052 | |
| idea_name | reqlan rq/language/syntax.rq | Idea names are identifiers or double-quoted strings. Unquoted names follow identifier rules and may use letters, digits, underscores, and dashes, for example myidea, my_idea, or dash-or_underscore_delimited-idea. Quoted names allow spaces and other characters when wrapped in double quotes. Idea names must be unique within their ideaset or file. An idea, one-liner, and ideaset must not share a name in the same file. Idea names should not use reserved keywords. | 0.063 | |
| ideaset | reqlan rq/language/syntax.rq | An ideaset is a parenthesized, comma-separated list of idea names. Ideaset members may be unquoted identifiers or quoted strings. Ideasets act as namespace containers for ideas, nested ideasets, and references. A bare bracket reference `[ideaset_name]` targets the ideaset declaration in the same file per [same_file_reference]. A bracket reference `[ideaset.member]` targets the member leaf per [references_to_subidea]. | 0.108 | |
| inline_code | reqlan rq/language/syntax.rq | done | Single-backtick spans ( `…` ) are opaque `INLINE_CODE`. They may show example syntax such as a quoted path plus idea. The grammar does not parse bracket or file references inside the span. Check and the language server must not report those examples as unresolved ["../reference_types.rq".file_reference] or idea refs. Related: [code_snippets], ["../core_analysis/rust_port.rq".comment_span_align]. | 0.165 |
| lists | reqlan rq/language/syntax.rq | Parenthesized lists contain newline-separated items. Each list item is either a one-liner or a nameless block idea in curly braces. Lists may appear as attribute values and inside block bodies. Named lists use a label followed by a parenthesized item list; the opening parenthesis must be followed by a newline before the first item. Nested lists may appear inside block values or as list items; the opening parenthesis must be followed by a newline before the first item. Inline parentheses in body prose — for example continuous ( " live " ) physics or ( pixelRatio 1, no WebGL ) — are plain text, not lists. | 0.055 | |
| main_desription_lists_allowed | reqlan rq/language/syntax.rq | - lists are valid in. - so this should not raise any error. s | 0.040 | |
| markdown_links | reqlan rq/language/syntax.rq | done | Markdown `[label](target)` links are supported; the label is not treated as an idea reference. Example: testing requirements and the golden corpus. Related: ["../development/core.rq".testing], ["../core_analysis/rust_port.rq".golden_corpus]. | 0.055 |
| naked_strings_in_body | reqlan rq/language/syntax.rq | Quoted text in idea bodies, attribute values, and list items is plain prose, not a string literal. Quote characters are preserved in the body text. For example, " Fit to view " in a bullet line is body text. String literals are reserved for import paths, top-level quoted idea names, and quoted paths inside bracket references. Quoted path-like body text is not a ["../reference_types.rq".file_reference]: ["../reference_types.rq".reference_edgecase]. | 0.065 | |
| name_only_ideas_it_should_be_possible_to_use_name_only_ideas_without_a_body | reqlan rq/language/syntax.rq | 0.040 | ||
| no_name_idea_safe_warning | reqlan rq/language/syntax.rq | done | A top-level nameless curly-brace block — `{... }` with no idea name — must not take down the parser or the language server workspace. Parse the block as a recoverable anonymous top-level element, emit a descriptive warning that a name is required before `{`, and continue so later ideas, imports, and links still work. Nameless blocks inside parenthesized lists remain valid list items per [lists]; only top-level nameless blocks warn. Related recovery posture: ["./imports.rq".import_error_recovery]. Block shape: [block_idea]. Fenced examples must stay opaque per [code_snippets] so braces inside snippets cannot desync structural depth. Non-termination ( lex / parse never finishes ) is a different failure mode: ["./parser_lexer.rq".parse_budget_timeout]. | 0.072 |
| open_file_reference_sequencing | reqlan rq/language/syntax.rq | done | When the editor opens a `.rq` buffer, reference marks follow ["../extension/language/support/open-file-sequencing.rq".open_file_algorithm]. The open buffer stays file-local ( ["../indexer/indexer.rq".local_symbolic_analysis] ). Cross-file inbound waits for ["../indexer/cache-reuse.rq".unify_inbound_indexes] and ["../extension/language/support/open-file-sequencing.rq".lazy_features_after_outbound]. | 0.193 |
| reference_brackets | reqlan rq/language/syntax.rq | Single-bracket references use square brackets around a target. Forms include ideaset-only, idea-only, ideaset dot idea, and idea dot attribute targets. An idea dot attribute target follows [attribute_namespacing]. | 0.263 | |
| reference_embedding | reqlan rq/language/syntax.rq | References may appear inline in description, plan, or other attribute values. References may be declared explicitly in @ references or implied by mention elsewhere. Reference kinds include dependency, incompatible with, applies to, and related to. References may use wildcards and apply to namespaces or ideasets — see ["./imports.rq".wildcard_references] for the qualified path + idea-pattern form. | 0.209 | |
| reference_file | reqlan rq/language/syntax.rq | References may target arbitrary files, not only. rq files. File reference syntax uses a bracketed quoted path. A relative path resolves from the document directory. When that path climbs with `..` and the file is not there, the same path is tried from each ancestor directory up to the workspace folder. The document-directory file wins when it exists. Line or line-range references append `L#n` or `L#n-m` after the path inside the brackets. Test-name references append `:` and the test title after the path ( for example `./app.test.ts:lists items` ). The first `:` after the path starts the title; later `:` characters stay in the title ( `e2e: …` ). `://` and a Windows drive `C:` / `C:/` are part of the path, not a test suffix. Symbol references append a dot-separated symbol path after the quoted file path. Quoted body text is not a file reference: ["../reference_types.rq".reference_edgecase]. | 0.266 | |
| reference_qualified | reqlan rq/language/syntax.rq | Cross-file references may qualify an import path or alias with an idea name. Qualified wikilinks may combine a quoted import path with a dot and idea name. A quoted path opens the target file as an ideaset ( ["./imports.rq".anonymous_imports_allowed] ). Partial from-import of that path does not restrict which ideas the quoted path can name. | 0.247 | |
| reference_resolution_order | reqlan rq/language/syntax.rq | done | For each `.rq` file, identify the names in local scope, then resolve references. Sequence: 1. Collect all idea, one-liner, and ideaset declarations in the file. Declaration order does not change which names are in scope. 2. Collect reference candidates in the file. 3. Resolve each candidate against those local declarations. 4. Resolve imports only for candidates that have no local match. Stop import lookup for a candidate when a local match exists. The language server and the indexer must use this sequence. Open-file editor underlines follow [open_file_reference_sequencing]. Related: [same_file_reference], [ideaset], ["./imports.rq".import_tokenisation], ["../indexer/indexer.rq".local_symbolic_analysis]. | 0.053 |
| reference_url | reqlan rq/language/syntax.rq | done | A bracket reference may target an unquoted absolute URL ( `scheme://…` ). Example: `[https://reqlan.com/]`. The URL is one token; `://` is not a line comment. Unbracketed URLs in body prose stay text. Quoted remote paths stay [reference_file] ( `["https://example.com/file.ts"]` ). Index and check: ["../reference_types.rq".url_reference]. | 0.137 |
| reference_wikilink | reqlan rq/language/syntax.rq | Double-bracket wikilinks use doubled square brackets around a target. Wikilinks may include an obsidian-style alias pipe with a display label after the target. A bare pipe character in body prose — for example kind: idea | file | selection — is plain text, not wikilink syntax. | 0.230 | |
| references_to_subidea | reqlan rq/language/syntax.rq | done | It is valid to reference a member of an [ideaset] as `[ideaset.member]`, for example [example_ideaset.subidea1]. The indexer must record that reference on the namespace leaf node. In this example the leaf is [subidea1], not [example_ideaset]. Related: [reference_brackets], [same_file_reference], ["../reference_types.rq".idea_reference], ["../indexer/indexer.rq".index]. | 0.167 |
| round_brackets | reqlan rq/language/syntax.rq | Round brackets indicate a list of ideas or attributes. Items may be separated by commas or newlines. Attribute list values may use commas or newlines; see @ example_list_attribute_using_commas and @ example_list_attribute_using_newlines. Parentheses in body prose — including API call shapes like cytoscape. animate ( { fit, easing: ' ease-out-cubic ' } ) — are plain text, not list syntax. | 0.045 | |
| same_file_reference | reqlan rq/language/syntax.rq | [reference_brackets] and [reference_wikilink] may target an idea, one-liner, or [ideaset] in the same file. The target may be declared before or after the reference. Forward references are valid. Circular references between declarations in the same file are valid. Resolution order: [reference_resolution_order]. | 0.100 | |
| simple_idea | reqlan rq/language/syntax.rq | A one-liner idea is written as a name followed by unstructured body text on the same line. A name-only idea is a one-liner with just the name and no body text. One-liner ideas do not continue onto subsequent lines. A `{` that is not immediately after the name is body text, not a block opener — see ["./syntax-edge-cases.rq".one_liner_curly_brace_context]. `name {}` and `name {hello}` are [block_idea] forms, not one-liners. | 0.075 | |
| string_and_reference_apostrophes | reqlan rq/language/syntax.rq | strings should use double or single apostrophes interchangeably and support backslash escapes. | 0.040 | |
| string_literals | reqlan rq/language/syntax.rq | String literals in import paths and quoted idea names may use double or single quotes. Escaped characters inside strings follow standard backslash escaping. | 0.064 | |
| subidea1 | reqlan rq/language/syntax.rq | hello | 0.062 | |
| subidea2 | reqlan rq/language/syntax.rq | hi, i'm a subidea | 0.040 | |
| idea-leading-whitespace | reqlan rq/language/syntax_whitespace.rq | A block body can have spaces or tabs before the text. The lexer counts a space and a tab as whitespace. A tab is one whitespace character. The parser does not replace a tab with spaces. The base indent is the whitespace at the start of the first body line. The first body line is the first line of body text in the block. The first body line can start after column 0. The base indent is still the whitespace on that line. A body line with the same whitespace as the base indent has no leading whitespace in the parsed text. A body line keeps the whitespace that remains after the base indent. The parser removes the base indent only when the line starts with that same whitespace. An attribute on its own line stays an attribute. Example: the first body line has four spaces. A later line with four spaces has no leading whitespace. A later line with eight spaces has four spaces in the parsed text. This line has the same four spaces as the first body line. This line has eight spaces. | 0.040 | |
| syntax_whitespace | reqlan rq/language/syntax_whitespace.rq | whitespace is not significant in attributes. this line is not an idea, it is part of the main content attribute ["../ontology.rq".attribute] | 0.040 |
Cluster graph
Initialising graph…