@hydranium/cli 1.0.0-next.308 → 1.0.0-next.309

package/src/commands/init-wizard.ts

@@ -55,7 +55,7 @@
  */
 
 import * as path from 'node:path';
-import { DEFAULT_INIT_HEADS, INIT_HEADS, type InitHead, isNonEmptyDir } from './init.js';
+import { DEFAULT_INIT_HEADS, INIT_HEADS, type InitHead, isNonEmptyDir, isUsableExtension, memberPlacements } from './init.js';
 import { kebab } from './kebab.js';
 import { InitWizardCancelled, OPTIONAL_HEAD_CHOICES, type PromptPort } from './init-prompt.js';
 import { type WorkspaceDetection } from './init-workspace.js';
@@ -159,13 +159,13 @@ export function formatCommand(argv: readonly string[]): string {
 /** Validate a file extension, and reject one another grammar already claims. */
 function extensionProblem(value: string, taken: ReadonlySet<string>): string | undefined {
    const extension = value.replace(/^\./, '');
-   if (!/^[A-Za-z0-9][A-Za-z0-9-]*$/.test(extension)) {
+   if (!isUsableExtension(extension)) {
       return `'${value}' is not a usable file extension.`;
    }
    // Checked here rather than left to the scaffolder so the answer is corrected
    // while the grammar that owns it is still on screen. Langium routes documents
    // to a language BY extension, so a duplicate is a silent mis-route.
-   return taken.has(extension) ? `'.${extension}' is already claimed by another grammar.` : undefined;
+   return taken.has(extension.toLowerCase()) ? `'.${extension}' is already claimed by another grammar.` : undefined;
 }
 
 /**
@@ -269,10 +269,11 @@ async function askWorkspaceMembership(
    if (detection === undefined) {
       return { monorepo: false };
    }
+   const uncovered = memberPlacements(detection).filter(placement => placement.coveredBy === undefined);
    const covered =
-      detection.coveredBy === undefined
-         ? `The root manifest has no entry covering it, so one is printed for you to add.`
-         : `Already covered by the "${detection.coveredBy}" workspaces entry.`;
+      uncovered.length === 0
+         ? 'Its packages are already covered by the workspaces entries.'
+         : `The root manifest has no entry covering ${uncovered.map(placement => placement.path).join(', ')}, so ${uncovered.length === 1 ? 'one is' : 'they are'} printed for you to add.`;
    // The placement is named, not just the root. The root alone reads as "this
    // ran somewhere I did not ask for" whenever the command was issued from a
    // different directory than the target, which is the normal case.
@@ -365,7 +366,7 @@ export async function runInitWizard(
       const grammar = await askGrammar(prompt, grammars.length, grammars.length === 0 ? name : undefined, takenNames, takenExtensions);
       grammars.push(grammar);
       takenNames.add(grammar.name);
-      takenExtensions.add(grammar.extension);
+      takenExtensions.add(grammar.extension.toLowerCase());
    } while (await prompt.confirm({ message: 'Add another grammar?', initialValue: false }));
 
    const withDiagram = await askDiagramGrammar(prompt, heads, grammars);

package/src/commands/init-workspace.ts

@@ -169,14 +169,6 @@ export interface WorkspaceDetection {
    readonly workspaces: readonly string[];
    /** POSIX path of the target relative to {@link rootDir}, e.g. `packages/foo`. */
    readonly targetPath: string;
-   /**
-    * The `workspaces` glob already covering {@link targetPath}, if any.
-    *
-    * Absent means the root manifest needs a new entry — which is why this is
-    * computed per target rather than assumed: a `packages/*` glob covers a new
-    * package for free, while a repo that lists its examples one by one does not.
-    */
-   readonly coveredBy?: string;
    /** The npm scope the sibling packages agree on (`@acme`), when they agree. */
    readonly scope?: string;
    /**
@@ -454,7 +446,6 @@ export function detectWorkspace(targetDir: string, probe: WorkspaceProbe): Works
       rootDir,
       workspaces,
       targetPath,
-      coveredBy: workspaces.find(glob => workspaceGlobCovers(glob, targetPath)),
       scope: inferPackageScope(rootDir, workspaces, probe),
       baseTsconfig: base && posixRelative(absoluteTarget, path.join(rootDir, base.file)),
       baseCompilerOptions: base?.compilerOptions,

package/src/commands/init.ts

@@ -11,7 +11,15 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { buildInitTemplates, readFrameworkVersion, workspaceRootPins } from './init-templates.js';
 import { kebab } from './kebab.js';
-import { createNodeWorkspaceProbe, detectWorkspace, parseNpmVersion, type JsonValue, type WorkspaceProbe } from './init-workspace.js';
+import {
+   createNodeWorkspaceProbe,
+   detectWorkspace,
+   parseNpmVersion,
+   workspaceGlobCovers,
+   type JsonValue,
+   type WorkspaceDetection,
+   type WorkspaceProbe
+} from './init-workspace.js';
 
 /**
  * The protocol heads a scaffold can start, in composition order.
@@ -28,6 +36,35 @@ export type InitHead = (typeof INIT_HEADS)[number];
 /** The heads a scaffold emits when `--heads` is not given. */
 export const DEFAULT_INIT_HEADS: readonly InitHead[] = ['lsp', 'data'];
 
+/**
+ * The library packages of a scaffolded project, each in the directory of its
+ * name, in the order a workspace lists them.
+ */
+export const INIT_MEMBERS = ['protocol', 'server'] as const;
+
+/** One library member — see {@link INIT_MEMBERS}. */
+export type InitMember = (typeof INIT_MEMBERS)[number];
+
+/** A member's path relative to the workspace root, and the `workspaces` entry already covering it. */
+export interface InitMemberPlacement {
+   readonly path: string;
+   readonly coveredBy?: string;
+}
+
+/**
+ * Where each member lands in a detected workspace.
+ *
+ * Judged per member rather than for the project directory, which holds no
+ * package: a root listing its members one by one needs an entry for each,
+ * while a `packages/*` glob covers none of them one level deeper.
+ */
+export function memberPlacements(detection: WorkspaceDetection): readonly InitMemberPlacement[] {
+   return INIT_MEMBERS.map(member => {
+      const memberPath = `${detection.targetPath}/${member}`;
+      return { path: memberPath, coveredBy: detection.workspaces.find(glob => workspaceGlobCovers(glob, memberPath)) };
+   });
+}
+
 /** True for a string naming one of {@link INIT_HEADS}. */
 export function isInitHead(value: string): value is InitHead {
    return (INIT_HEADS as readonly string[]).includes(value);
@@ -254,11 +291,21 @@ function isPascalIdentifier(value: string): boolean {
    return /^[A-Za-z][A-Za-z0-9]*$/.test(value);
 }
 
-/** Strip a leading dot and reject an extension that is empty or dotted through. */
+/**
+ * True for a file extension, without its leading dot, that is safe in an
+ * emitted file name and string literal: letters, digits and dashes.
+ */
+export function isUsableExtension(extension: string): boolean {
+   return /^[A-Za-z0-9][A-Za-z0-9-]*$/.test(extension);
+}
+
+/** Strip a leading dot and reject an extension {@link isUsableExtension} refuses. */
 function normalizeExtension(value: string, grammar: string): string {
    const extension = value.replace(/^\./, '');
-   if (extension.length === 0) {
-      throw new Error(`Invalid extension '${value}' for grammar '${grammar}': an extension cannot be empty.`);
+   if (!isUsableExtension(extension)) {
+      throw new Error(
+         `Invalid extension '${value}' for grammar '${grammar}': use letters, digits and dashes, starting with a letter or digit.`
+      );
    }
    return extension;
 }
@@ -282,6 +329,11 @@ function resolveGrammar(spec: InitGrammarSpec, projectId: string, qualify: boole
    if (extensions.length === 0) {
       throw new Error(`Invalid --extensions for grammar '${spec.name}': at least one extension is required.`);
    }
+   if (spec.languageId !== undefined && !/^[a-z0-9][a-z0-9-]*$/.test(spec.languageId)) {
+      throw new Error(
+         `Invalid --language-id '${spec.languageId}' for grammar '${spec.name}': use lowercase letters, digits and dashes, e.g. 'my-lang'.`
+      );
+   }
    return {
       grammar: spec.name,
       grammarId,
@@ -369,15 +421,18 @@ function assertNoCollisions(grammars: readonly InitGrammarNames[]): void {
       }
       byLanguageId.set(grammar.languageId, grammar.grammar);
 
+      // Case-folded: a starter file is named by extension, and `nodes.Foo` and
+      // `nodes.foo` are one file on a case-insensitive file system.
       for (const extension of grammar.extensions) {
-         const clashingExtension = byExtension.get(extension);
+         const key = extension.toLowerCase();
+         const clashingExtension = byExtension.get(key);
          if (clashingExtension !== undefined) {
             throw new Error(
                `File extension '.${extension}' is claimed by both '${clashingExtension}' and '${grammar.grammar}'. ` +
                   'Langium routes documents by extension, so each grammar needs its own.'
             );
          }
-         byExtension.set(extension, grammar.grammar);
+         byExtension.set(key, grammar.grammar);
       }
    }
 }
@@ -515,31 +570,36 @@ export function runInit(options: InitCommandOptions): void {
       write('\n');
       write(`Workspace root: ${detection.rootDir}\n`);
       if (detection.baseTsconfig !== undefined) {
-         write(`  tsconfig.json extends ${detection.baseTsconfig}, minus the options it inherits unchanged.\n`);
+         write(
+            `  Each package's tsconfig.json extends the root's ${path.posix.basename(detection.baseTsconfig)}, minus the options it inherits unchanged.\n`
+         );
       } else {
-         write('  No root tsconfig carries compilerOptions, so the emitted one stands alone.\n');
+         write("  No root tsconfig carries compilerOptions, so each package's stands alone.\n");
       }
       if (detection.printWidth !== undefined) {
          write(`  Sources wrapped at ${detection.printWidth} columns, from ${detection.rootDir}'s formatter config.\n`);
       }
       if (detection.oxlintConfig !== undefined || detection.eslintConfig !== undefined) {
          write(
-            `  A lint script was added — ${detection.oxlintConfig ?? detection.eslintConfig} says this repo lints. Adjust it if your invocation differs.\n`
+            `  Each package got a lint script — ${detection.oxlintConfig ?? detection.eslintConfig} says this repo lints. Adjust them if your invocation differs.\n`
          );
       }
       // Printed rather than applied: `init` writes inside the target directory
       // and nowhere else, so a scaffold can never surprise-edit a manifest that
       // is under review, mid-rebase, or simply not the caller's to change.
-      if (detection.coveredBy === undefined) {
-         write(`  Add this to "workspaces" in ${path.join(detection.rootDir, 'package.json')}:\n`);
-         write(`    "${detection.targetPath}"\n`);
-      } else {
-         write(`  Already covered by the "${detection.coveredBy}" workspaces entry.\n`);
+      const placements = memberPlacements(detection);
+      const uncovered = placements.filter(placement => placement.coveredBy === undefined);
+      if (uncovered.length > 0) {
+         write(`  Add ${uncovered.length === 1 ? 'this' : 'these'} to "workspaces" in ${path.join(detection.rootDir, 'package.json')}:\n`);
+         write(`${uncovered.map(placement => `    "${placement.path}"`).join(',\n')}\n`);
+      }
+      for (const placement of placements.filter(candidate => candidate.coveredBy !== undefined)) {
+         write(`  ${placement.path} is already covered by the "${placement.coveredBy}" workspaces entry.\n`);
       }
       const pins = workspaceRootPins(composition.heads).map(([name, version]) => `    "${name}": "${version}"`);
       write(
          `  Add these to "devDependencies" in ${path.join(detection.rootDir, 'package.json')}, so another member's version of one ` +
-            `cannot displace the copy this package shares with the framework:\n${pins.join(',\n')}\n`
+            `cannot displace the copy these packages share with the framework:\n${pins.join(',\n')}\n`
       );
       if (composition.packaging.scope === undefined && detection.scope !== undefined) {
          write(`  Sibling packages all use the "${detection.scope}" scope; pass --scope ${detection.scope} to match them.\n`);
@@ -547,13 +607,23 @@ export function runInit(options: InitCommandOptions): void {
    }
    write('\n');
    write('Next steps:\n');
-   write(`  cd ${options.targetDir}\n`);
-   write('  npm install\n');
-   write('  npm run build            # langium generate + tsc\n');
-   write('  npm test                 # the scaffolded DI-composition test\n');
+   // A workspace member's project has no manifest of its own, so its steps run
+   // from the workspace root and name the server by `--prefix`.
+   const server = detection === undefined ? 'server' : `${detection.targetPath}/server`;
+   if (detection === undefined) {
+      write(`  cd ${options.targetDir}\n`);
+      write('  npm install\n');
+      write('  npm run build            # langium generate + tsc, every package\n');
+      write('  npm test                 # the server tests\n');
+   } else {
+      write(`  cd ${detection.rootDir}\n`);
+      write('  npm install\n');
+      write(`  npm --prefix ${server} run build   # langium generate + tsc, protocol included\n`);
+      write(`  npm --prefix ${server} test\n`);
+   }
    // `npx`, not a bare invocation: `@hydranium/cli` is a devDependency of the
    // scaffold, so the binary is on PATH inside an npm script and nowhere else.
-   write('  npx hydranium-cli reflect --services ./lib/services.js\n');
+   write(`  npx hydranium-cli reflect --services ./${server}/lib/node/services.js\n`);
    write('\n');
    write('The emitted sources carry no license header — run your own header tool if\n');
    write('your repo gates them. See the README section on that.\n');

package/templates/gitignore

@@ -0,0 +1 @@
+node_modules/

package/templates/protocol/gitignore

@@ -0,0 +1,3 @@
+node_modules/
+lib/
+*.tsbuildinfo

package/templates/protocol/src/__GRAMMAR_ID__-diagram-types.ts

@@ -0,0 +1,41 @@
+// GLSP diagram-type and element-type ids for the __GRAMMAR__ diagram, which the
+// server stamps onto the graph and every client registers.
+//
+// Declared once, here, for both ends. A drift between them fails silently:
+// sprotty's registries are exact-key maps with no prefix fallback, so an id the
+// client does not know yields an element with none of a node's features,
+// rendered by `MissingView` with only a `no registered view for type '…'`
+// console warning. Nothing fails server-side.
+//
+// The ids stay namespaced under the GLSP defaults (`node:` / `edge:`) so a
+// reader can tell a node id from an edge id at a glance.
+
+import { DefaultTypes } from '@eclipse-glsp/protocol';
+import { __GRAMMAR_ID_CONST___LANGUAGE } from './generated-hydranium/languages.js';
+
+/**
+ * The GLSP diagram type — the string GLSP routes every per-diagram-type request
+ * by. A mismatch silently DROPS the request rather than reporting an unknown
+ * diagram type. Read from the language id, so renaming the language renames
+ * the diagram type at the next `generate`.
+ */
+export const __GRAMMAR_ID_CONST___DIAGRAM_TYPE = __GRAMMAR_ID_CONST___LANGUAGE.languageId;
+
+/** A `__NODE_RULE__` — the starter grammar's one named, referenceable node. */
+export const __GRAMMAR_ID_CONST___NODE_TYPE = `${DefaultTypes.NODE}:__GRAMMAR_ID__-node`;
+
+/** A resolved `target` reference, drawn as a connection between two nodes. */
+export const __GRAMMAR_ID_CONST___EDGE_TYPE = `${DefaultTypes.EDGE}:__GRAMMAR_ID__-target`;
+
+/**
+ * Every element type id the server stamps.
+ *
+ * A tuple, so {@link __GRAMMAR__ElementType} is a union of the ids rather than
+ * `string`: a client table keyed by that union does not compile while an id
+ * lacks its registration. Nothing holds the tuple to the constants above, so
+ * an id declared without joining it escapes that check.
+ */
+export const __GRAMMAR_ID_CONST___ELEMENT_TYPES = [__GRAMMAR_ID_CONST___NODE_TYPE, __GRAMMAR_ID_CONST___EDGE_TYPE] as const;
+
+/** One of the element type ids in {@link __GRAMMAR_ID_CONST___ELEMENT_TYPES}. */
+export type __GRAMMAR__ElementType = (typeof __GRAMMAR_ID_CONST___ELEMENT_TYPES)[number];

package/templates/server/src/glsp/__GRAMMAR_ID__/create-node-operation-handler.ts

@@ -21,17 +21,18 @@
 // starter grammar persists no bounds, so there is nowhere to put a coordinate: the
 // node is appended at the end of the document and the client places it.
 //
-// Like `types.ts`, `gmodel-factory.ts` and `diagram-configuration.ts`, this file
-// knows the starter grammar's shape — the `nodes` list and the `__NODE_RULE__`
-// it holds. Replacing the grammar means replacing these four together.
+// Like protocol's `__GRAMMAR_ID__-diagram-types.ts`, `gmodel-factory.ts` and
+// `diagram-configuration.ts`, this file knows the starter grammar's shape — the
+// `nodes` list and the `__NODE_RULE__` it holds. Replacing the grammar means
+// replacing these four together.
 
 import { type Command, type CreateNodeOperation, JsonCreateNodeOperationHandler, type MaybePromise } from '@eclipse-glsp/server';
 import { appendChild } from '@hydranium/core';
 import { HydraniumGlspRecordingCommand } from '@hydranium/glsp-server';
 import { findNextUnique } from '@hydranium/protocol';
+import { __GRAMMAR_ID_CONST___NODE_TYPE } from '__PROTOCOL_PACKAGE__';
 import { injectable } from 'inversify';
 import type { __NODE_RULE__ } from '../../language-server/ast.js';
-import { __GRAMMAR_ID_CONST___NODE_TYPE } from './types.js';
 import type { __GRAMMAR__GlspState } from './state.js';
 
 /** Proposed name for a new node, uniquified against the ones the document already has. */

package/templates/server/src/glsp/__GRAMMAR_ID__/gmodel-factory.ts

@@ -6,12 +6,15 @@
 // pointing at an id that does not exist fails client-side with a far less
 // obvious error than a missing edge. An unresolved reference is SKIPPED rather
 // than treated as an error: a dangling reference is ordinary editing state, and
-// the LSP head already reports it as a diagnostic.
+// the LSP head already reports it as a diagnostic. A reference into another
+// document is skipped for the same reason: the graph holds only this
+// document's nodes, so its target has no id here.
 
 import { DefaultTypes, GEdge, GGraph, GLabel, type GModelFactory, GNode, ModelState } from '@eclipse-glsp/server';
+import { AstUtils } from '@hydranium/langium';
+import { __GRAMMAR_ID_CONST___EDGE_TYPE, __GRAMMAR_ID_CONST___NODE_TYPE } from '__PROTOCOL_PACKAGE__';
 import { inject, injectable } from 'inversify';
 import type { __ENTRY_RULE__ } from '../../language-server/ast.js';
-import { __GRAMMAR_ID_CONST___EDGE_TYPE, __GRAMMAR_ID_CONST___NODE_TYPE } from './types.js';
 import type { __GRAMMAR__GlspState } from './state.js';
 
 @injectable()
@@ -40,7 +43,7 @@ export class __GRAMMAR__GModelFactory implements GModelFactory {
       }
       for (const node of root.nodes) {
          const target = node.target?.ref;
-         if (!target) {
+         if (!target || AstUtils.findRootNode(target) !== root) {
             continue;
          }
          const sourceId = this.modelState.index.createId(node);

package/templates/server/src/{services.ts → node/services.ts}

@@ -1,11 +1,15 @@
 // Zero-arg service factory for the headless `hydranium-cli` tooling: the
 // `reflect` / `lint-grammar` / `validate` subcommands import this via
-// `--services ./lib/services.js`. The head wires its own filesystem here.
+// `--services ./lib/node/services.js`. The head wires its own filesystem here.
+//
+// Behind the package's `./node` entry rather than its root because it reads
+// the real filesystem: the root stays loadable in a browser worker, which has
+// no `node:fs`.
 //
 // The contract is language-count-agnostic — a second grammar needs no edit here.
 
 import { NodeFileSystem } from '@hydranium/core/node';
-import { create__NAME__Services } from './language-server/__PROJECT_ID__-module.js';
+import { create__NAME__Services } from '../language-server/__PROJECT_ID__-module.js';
 
 export function createServices(): ReturnType<typeof create__NAME__Services> {
    return create__NAME__Services({ ...NodeFileSystem });

package/templates/server/test/__GRAMMAR_ID__-diagram.test.ts

@@ -1,8 +1,9 @@
-// The starter create-node handler, run the way a client runs it: an in-process
-// GLSP server opens a document, a create-node operation adds a node, and an undo
-// and a redo take it out and put it back. Every step must keep the nodes the
-// document already had, and its comments: the diagram writes the document from
-// its AST, which carries none.
+// The starter diagram, run the way a client runs it: an in-process GLSP server
+// opens a document. A create-node operation adds a node, and an undo and a redo
+// take it out and put it back; every step must keep the nodes the document
+// already had, and its comments, since the diagram writes the document from its
+// AST, which carries none. A reference into another document draws no edge,
+// since the graph holds no node for its target.
 
 import 'reflect-metadata';
 import { type Action, CreateNodeOperation, RedoAction, ServerModule, SetDirtyStateAction, UndoAction } from '@eclipse-glsp/server';
@@ -11,11 +12,11 @@ import { makeScratchWorkspace, type ScratchWorkspace } from '@hydranium/core/tes
 import { HydraniumGlspAppModule } from '@hydranium/glsp-server';
 import { type GlspHarness, makeGlspHarness } from '@hydranium/glsp-server/testing';
 import { waitFor } from '@hydranium/protocol/testing';
+import { __GRAMMAR_ID_CONST___DIAGRAM_TYPE, __GRAMMAR_ID_CONST___NODE_TYPE } from '__PROTOCOL_PACKAGE__';
 import { afterEach, describe, expect, it } from 'vitest';
 import { __GRAMMAR__DiagramModule } from '../src/glsp/__GRAMMAR_ID__/diagram-module.js';
 import type { __GRAMMAR__GlspState } from '../src/glsp/__GRAMMAR_ID__/state.js';
-import { __GRAMMAR_ID_CONST___DIAGRAM_TYPE, __GRAMMAR_ID_CONST___NODE_TYPE } from '../src/glsp/__GRAMMAR_ID__/types.js';
-import { createServices } from '../src/services.js';
+import { createServices } from '../src/node/services.js';
 
 let workspace: ScratchWorkspace | undefined;
 let diagram: GlspHarness<__GRAMMAR__GlspState> | undefined;
@@ -65,4 +66,24 @@ describe('__GRAMMAR__ diagram', () => {
          redone: `${original}\nnode Node`
       });
    });
+
+   it('draws no edge for a reference that resolves into another document', async () => {
+      workspace = makeScratchWorkspace({ prefix: '__GRAMMAR_ID__-diagram-' });
+      workspace.write('declaring.__EXTENSION__', 'node second');
+      const file = workspace.write('referencing.__EXTENSION__', 'node first -> second');
+      const { shared } = createServices();
+      await initializeWorkspaceProgrammatically(shared, workspace.root);
+      diagram = makeGlspHarness<__GRAMMAR__GlspState>({
+         serverModule: new ServerModule().configureDiagramModule(new __GRAMMAR__DiagramModule()),
+         diagramType: __GRAMMAR_ID_CONST___DIAGRAM_TYPE,
+         appModules: [new HydraniumGlspAppModule({ shared })]
+      });
+      await diagram.start();
+      await diagram.openDocument(file);
+
+      // The reference resolves, so the missing edge is the document rule and
+      // not a dangling reference.
+      expect(diagram.state.sourceRoot?.nodes[0].target?.ref?.name).toBe('second');
+      expect(diagram.state.root.children.map(child => child.type)).toEqual([__GRAMMAR_ID_CONST___NODE_TYPE]);
+   });
 });

package/templates/workspace/nodes.__EXTENSION__

@@ -0,0 +1,5 @@
+/** The first node. Hover a name to read its comment. */
+node First
+
+/** A second node, pointing at the first in the same file. */
+node Second -> First

package/templates/workspace/references.__EXTENSION__

@@ -0,0 +1,2 @@
+/** Points at a node declared in nodes.__EXTENSION__: hover the target to read its comment from there. */
+node Third -> Second

package/templates/server/src/glsp/__GRAMMAR_ID__/types.ts

@@ -1,26 +0,0 @@
-// GLSP diagram-type and element-type ids for the __GRAMMAR__ diagram.
-//
-// **Authoritative half of a client/server contract.** Every id here has to be
-// registered on the client too: sprotty's registries are exact-key maps with no
-// prefix fallback, so an id the client does not know yields an element with none
-// of a node's features, rendered by `MissingView` with only a
-// `no registered view for type '…'` console warning. Nothing fails server-side.
-//
-// The ids stay namespaced under the GLSP defaults (`node:` / `edge:`) so a
-// reader can tell a node id from an edge id at a glance.
-
-import { DefaultTypes } from '@eclipse-glsp/server';
-
-/**
- * The GLSP diagram type — the string GLSP routes every per-diagram-type request
- * by. Mirrored by the client; a mismatch silently DROPS the request rather than
- * reporting an unknown diagram type. Same value as the language id, so the two
- * cannot drift apart as a diagram gains element types.
- */
-export const __GRAMMAR_ID_CONST___DIAGRAM_TYPE = '__LANGUAGE_ID__';
-
-/** A `__NODE_RULE__` — the starter grammar's one named, referenceable node. */
-export const __GRAMMAR_ID_CONST___NODE_TYPE = `${DefaultTypes.NODE}:__GRAMMAR_ID__-node`;
-
-/** A resolved `target` reference, drawn as a connection between two nodes. */
-export const __GRAMMAR_ID_CONST___EDGE_TYPE = `${DefaultTypes.EDGE}:__GRAMMAR_ID__-target`;