@gjsify/adwaita-web 0.51.1 → 0.53.0

package/src/shared-trees.spec.ts

@@ -16,6 +16,12 @@
 // no per-block case — a `switch` on a widget name here would be the per-surface branch
 // § 9 forbids, and the reason the corpus admits a block only when it needs no alias.
 //
+// `mountSharedTree` is SHIPPED code, not this driver's own — the renderer-specific half of
+// ADR 0051 that any consumer of this package may need (the same move #1726 made for
+// `gtk-host`), so it lives in `./shared-tree-builder.ts` rather than here. Its header
+// explains why THIS renderer needs a mount step the other two do not: these elements build
+// on connect.
+//
 // The readers below go through the REAL DOM the element rendered, never a state object of
 // its own: an element asserting against its own bookkeeping agrees with itself while the
 // page is wrong.
@@ -27,59 +33,43 @@
 
 import { describe, expect, it } from '@gjsify/unit';
 
+import { parseBlueprint, projectToSharedNode } from '@gjsify/blueprint';
 import {
+    ADJUSTMENT_AUTHORED_VECTORS,
     authoredTags,
     sharedTreeExpectations,
+    sharedTreePlacements,
     subjectIndexOf,
+    TOGGLE_ACTIVE_NAME_VECTORS,
+    withoutPlacements,
     type SharedTreeExpectation,
     type SharedTreeNode,
 } from '@gjsify/adwaita-core/conformance';
+import { attributeOf, hostTagOf } from '@gjsify/adwaita-core/tags';
 
-// `attributeOf` — `buttonLabel` -> `button-label` — comes from the corpus rather than
-// being spelled again here, because arm 13 of `check-generated-website-data.mjs` reads
-// gallery fences back through the SAME rule: two copies would let this driver and that
-// check agree with each other while the fence a reader copies means something else.
-import {
-    ADWAITA_GALLERY_SHARED_TREES,
-    attributeOf,
-    hostTagOf,
-} from '../../../../scripts/adwaita-gallery-shared-trees.mjs';
+// The corpus data itself, not the transforms: `scripts/` still owns the ONE gallery corpus
+// (ADR 0051), and this driver reads it here rather than transcribing it, the same as the
+// GTK and NativeScript drivers do.
+import { ADWAITA_GALLERY_SHARED_TREES } from '../../../../scripts/adwaita-gallery-shared-trees.mjs';
 
 import '@gjsify/adwaita-web';
 
-/**
- * The whole renderer-specific half of this driver: an element, its authored properties as
- * attributes, its children, in that order.
- *
- * A boolean is the ATTRIBUTE'S PRESENCE, which is what every element here reads
- * (`hasAttribute('revealed')`, `hasAttribute('expanded')`) — spelling `"true"` would set a
- * present attribute for `false` as well.
- */
-function build(node: SharedTreeNode): HTMLElement {
-    const el = document.createElement(hostTagOf(node.tag));
-    for (const [prop, value] of Object.entries(node.props ?? {})) {
-        if (typeof value === 'boolean') el.toggleAttribute(attributeOf(prop), value);
-        else el.setAttribute(attributeOf(prop), String(value));
-    }
-    for (const child of node.children ?? []) el.append(build(child));
-    return el;
-}
+import { mountSharedTree } from './shared-tree-builder.js';
 
 /**
  * Connect the authored root — these elements build on connect — run, and take it down again.
  *
  * The teardown is in a `finally` because a RED test must not leave a mounted tree behind:
  * the next test would then be reading a document two blocks deep, and the failure it
- * reported would name the wrong renderer.
+ * reported would name the wrong renderer. `mountSharedTree` is the shipped instantiation
+ * half; the `finally` around it is this suite's own isolation POLICY, not part of it.
  */
 function mounted<T>(node: SharedTreeNode, use: (root: Element) => T): T {
-    const host = document.createElement('div');
-    host.append(build(node));
-    document.body.append(host);
+    const { root, unmount } = mountSharedTree(node);
     try {
-        return use(host.firstElementChild!);
+        return use(root);
     } finally {
-        host.remove();
+        unmount();
     }
 }
 
@@ -116,6 +106,26 @@ function realised(root: Element, wanted: readonly string[]): Element[] {
     return [root, ...root.querySelectorAll('*')].filter((el) => set.has(el.tagName.toLowerCase()));
 }
 
+/**
+ * A Blueprint source as the `?shared-tree` door hands it over: projected by the one
+ * projection `@gjsify/vite-plugin-blueprint` serves, and refused when it dropped anything,
+ * as that door refuses it. Projected here rather than imported as a `.blp` file so these
+ * fixtures stay out of ADR 0053's census of shipped `.blp` files. The NativeScript driver
+ * (`packages/nativescript-bridge/adwaita/src/shared-trees.spec.ts`) builds the same sources.
+ */
+function blueprintTree(body: string): SharedTreeNode {
+    const { node, lost } = projectToSharedNode(
+        parseBlueprint(`using Gtk 4.0;\nusing Adw 1;\n\n${body}\n`, 'shared-trees.spec.blp'),
+    );
+    if (lost.length > 0) {
+        throw new Error(`the projection dropped ${lost.map((loss) => `${loss.kind} at line ${loss.line}`).join(', ')}`);
+    }
+    return node as SharedTreeNode;
+}
+
+/** The ids of an element's children, in DOM order. */
+const childIds = (el: Element | null): string[] => Array.from(el?.children ?? [], (child) => child.id);
+
 export const AdwSharedTreesTest = async () => {
     await describe('the shared corpus builds through adwaita-web', async () => {
         for (const block of ADWAITA_GALLERY_SHARED_TREES) {
@@ -130,6 +140,260 @@ export const AdwSharedTreesTest = async () => {
         }
     });
 
+    // THE TAGS A REAL `.blp` WRITES, through the real projection — the same sources the
+    // NativeScript driver builds, so the two renderers answer the same trees.
+    await describe('a .blp tree with the tags the builders learned', async () => {
+        await it('Gtk.Adjustment at `adjustment:` becomes the spin row range, and the value the row shows', () => {
+            const tree = blueprintTree(
+                'Adw.SpinRow { title: "Size"; adjustment: Adjustment { lower: 2; upper: 10; value: 4; step-increment: 2; }; }',
+            );
+            mounted(tree, (root) => {
+                expect((root as unknown as { adjustment: unknown }).adjustment).toStrictEqual({
+                    value: 4,
+                    lower: 2,
+                    upper: 10,
+                    stepIncrement: 2,
+                    pageIncrement: 2,
+                    pageSize: 0,
+                });
+                expect(root.querySelector('input')?.value).toBe('4');
+                // Consumed as data, as GtkBuilder leaves no adjustment in the widget tree.
+                expect(root.querySelector('gtk-adjustment')).toBe(null);
+            });
+        });
+
+        for (const vector of ADJUSTMENT_AUTHORED_VECTORS) {
+            await it(`ADJUSTMENT_AUTHORED_VECTORS through a .blp — ${vector.rule}`, () => {
+                const fields = Object.entries(vector.input)
+                    .map(([field, value]) => `${attributeOf(field)}: ${String(value)};`)
+                    .join(' ');
+                mounted(blueprintTree(`Adw.SpinRow { adjustment: Adjustment { ${fields} }; }`), (root) => {
+                    expect((root as unknown as { adjustment: unknown }).adjustment).toStrictEqual(vector.adjustment);
+                });
+            });
+        }
+
+        for (const vector of TOGGLE_ACTIVE_NAME_VECTORS) {
+            await it(`TOGGLE_ACTIVE_NAME_VECTORS — ${vector.rule}`, () => {
+                const toggles = vector.names
+                    .map(
+                        (name, index) =>
+                            `Adw.Toggle { ${name === null ? '' : `name: "${name}"; `}label: "T${index}"; }`,
+                    )
+                    .join(' ');
+                const tree = blueprintTree(`Adw.ToggleGroup { active-name: "${vector.activeName}"; ${toggles} }`);
+                mounted(tree, (root) => {
+                    // The ACTIVE BUTTON, read off the DOM — not the element's index.
+                    const buttons = Array.from(root.querySelectorAll('button.adw-toggle'));
+                    expect(buttons.length).toBe(vector.kept);
+                    expect(buttons.findIndex((button) => button.classList.contains('active'))).toBe(vector.active);
+                });
+            });
+        }
+
+        await it('Adw.Toggle carries its label into the button it becomes', () => {
+            const tree = blueprintTree(
+                'Adw.ToggleGroup { active: 1; Adw.Toggle { label: "List"; icon-name: "view-list-symbolic"; } Adw.Toggle { label: "Grid"; } }',
+            );
+            mounted(tree, (root) => {
+                const buttons = Array.from(root.querySelectorAll('button.adw-toggle'));
+                expect(buttons.map((button) => button.textContent)).toStrictEqual(['List', 'Grid']);
+                expect(buttons[1]?.classList.contains('active')).toBe(true);
+                expect(root.querySelector('gtk-image') !== null).toBe(true);
+            });
+        });
+
+        await it('Adw.NavigationPage brings its tag, title, can-pop and child into the navigation view', () => {
+            const tree = blueprintTree(`Adw.NavigationView {
+                Adw.NavigationPage { tag: "home"; title: "Home"; child: Gtk.Label { label: "Welcome"; }; }
+                Adw.NavigationPage { tag: "details"; title: "Details"; can-pop: false; child: Gtk.Label { label: "More"; }; }
+            }`);
+            mounted(tree, (root) => {
+                const view = root as unknown as {
+                    pages: readonly Element[];
+                    visiblePageTag: string | null;
+                    pushByTag(tag: string): boolean;
+                    canGoBack: boolean;
+                };
+                expect(view.pages.length).toBe(2);
+                expect(view.visiblePageTag).toBe('home');
+                expect(view.pages[0]?.querySelector('gtk-label')?.getAttribute('label')).toBe('Welcome');
+                expect(view.pushByTag('details')).toBe(true);
+                expect(view.visiblePageTag).toBe('details');
+                // `can-pop: false` is a GTK default of TRUE authored false — the case
+                // absence cannot spell, so the builder writes it through `canPop`.
+                expect(view.canGoBack).toBe(false);
+            });
+        });
+
+        await it('Adw.SidebarSection and Adw.SidebarItem become the sidebar model and its rows', () => {
+            const tree = blueprintTree(`Adw.Sidebar {
+                Adw.SidebarSection { title: "Places"; Adw.SidebarItem { title: "Home"; icon-name: "go-home-symbolic"; } Adw.SidebarItem { title: "Trash"; enabled: false; } }
+                Adw.SidebarSection { Adw.SidebarItem { title: "Hidden"; visible: false; } Adw.SidebarItem { title: "Music"; subtitle: "Library"; } }
+            }`);
+            mounted(tree, (root) => {
+                const sections = (
+                    root as unknown as {
+                        sections: readonly {
+                            title?: string;
+                            items: readonly { title: string; enabled?: boolean; visible?: boolean }[];
+                        }[];
+                    }
+                ).sections;
+                expect(sections.map((section) => section.title)).toStrictEqual(['Places', '']);
+                expect(sections.flatMap((section) => section.items.map((item) => item.title))).toStrictEqual([
+                    'Home',
+                    'Trash',
+                    'Hidden',
+                    'Music',
+                ]);
+                expect(sections[0]?.items[1]?.enabled).toBe(false);
+                expect(sections[1]?.items[0]?.visible).toBe(false);
+                // The ROWS: the hidden item's row is hidden, the disabled one insensitive.
+                const rows = Array.from(root.querySelectorAll<HTMLButtonElement>('button.adw-sidebar-item'));
+                expect(rows.map((row) => row.querySelector('.adw-sidebar-item-title')?.textContent)).toStrictEqual([
+                    'Home',
+                    'Trash',
+                    'Hidden',
+                    'Music',
+                ]);
+                expect(rows.map((row) => row.hidden)).toStrictEqual([false, false, true, false]);
+                expect(rows.map((row) => row.disabled)).toStrictEqual([false, true, false, false]);
+            });
+        });
+
+        await it('Adw.TabPage becomes a titled page around its child; a bare widget an untitled one', () => {
+            const tree = blueprintTree(`Adw.TabView {
+                Adw.TabPage { title: "Inbox"; child: Gtk.Label inbox { label: "3 new"; }; }
+                Adw.TabPage { title: "Drafts"; child: Gtk.Label drafts { label: "None"; }; }
+                Gtk.Label bare { label: "Loose"; }
+            }`);
+            mounted(tree, (root) => {
+                const pages = (root as unknown as { pages: readonly { title: string; content?: Element }[] }).pages;
+                expect(pages.map((page) => page.title)).toStrictEqual(['Inbox', 'Drafts', '']);
+                expect(
+                    pages.map((page) => page.content?.querySelector('gtk-label')?.id ?? page.content?.id),
+                ).toStrictEqual(['inbox', 'drafts', 'bare']);
+            });
+        });
+
+        await it('Gtk.ActionBar packs [start], [end], [center] and an untyped child as GtkBuildable does', () => {
+            const tree = blueprintTree(`Gtk.ActionBar {
+                revealed: false;
+                [start] Gtk.Button a {}
+                [end] Gtk.Button c {}
+                [start] Gtk.Button b {}
+                [end] Gtk.Button d {}
+                Gtk.Button e {}
+                [center] Gtk.Label centre { label: "Centre"; }
+            }`);
+            mounted(tree, (root) => {
+                expect(childIds(root.querySelector('.adw-action-bar-start'))).toStrictEqual(['a', 'b', 'e']);
+                expect(childIds(root.querySelector('.adw-action-bar-end'))).toStrictEqual(['d', 'c']);
+                expect(childIds(root.querySelector('.adw-action-bar-center'))).toStrictEqual(['centre']);
+                expect((root as HTMLElement).hidden).toBe(true);
+            });
+        });
+
+        await it('an authored false on a getter-only property keeps the presence rule instead of throwing', () => {
+            // `<adw-split-button>` exposes `active` as a read-only getter; assigning through it
+            // threw a bare TypeError out of the builder before the writability check.
+            mounted({ tag: 'AdwSplitButton', props: { active: false } }, (root) => {
+                expect(root.hasAttribute('active')).toBe(false);
+            });
+        });
+
+        await it('`center-widget:` is refused — GTK has no such property, so Gtk.Builder refuses it too', () => {
+            expect(() => mountSharedTree(blueprintTree('Gtk.ActionBar { center-widget: Gtk.Label {}; }'))).toThrow(
+                'has no slot "center-widget"',
+            );
+        });
+    });
+
+    await describe('the shared corpus is placed where it says', async () => {
+        // A CONTROL, not a table of where each slot lands. `withoutPlacements` is the tree a
+        // builder that never read `slot` hands this renderer — which is what all three
+        // builders did — so the two realised DOMs being identical is exactly that
+        // regression. NESTING AND ELEMENT NAME ONLY, because the `slot=` attribute is itself
+        // part of what the placed build writes: comparing markup would differ on the
+        // attribute alone and pass while the widget sat beside its destination.
+        const structure = (el: Element): string => `${el.localName}[${Array.from(el.children, structure).join(',')}]`;
+
+        for (const block of ADWAITA_GALLERY_SHARED_TREES) {
+            const placements = sharedTreePlacements(block.root);
+            if (placements.length === 0) continue;
+            const named = placements.map(({ path, slot }) => `${path} -> ${slot}`).join(', ');
+            await it(`${block.widget} — ${named}: the mounted DOM is not the unplaced one`, () => {
+                const placed = mounted(block.root, structure);
+                const unplaced = mounted(withoutPlacements(block.root), structure);
+
+                expect(placed === unplaced).toBe(false);
+            });
+        }
+
+        // Otherwise the loop above is green from emptiness — the corpus authored no slot at
+        // all until a `.blp` forced the question.
+        await it('the corpus authors a placement at all', () => {
+            expect(ADWAITA_GALLERY_SHARED_TREES.some((block) => sharedTreePlacements(block.root).length > 0)).toBe(
+                true,
+            );
+        });
+
+        // THE OTHER HALF OF READING A SLOT, and the corpus cannot carry it: a name this
+        // renderer has no destination for. `bindSlottedChildren` copies the NATIVE rule — an
+        // unmatched name is assigned nowhere and the child stays put — which is right for
+        // hand-written markup and says nothing to a builder realising an authored tree.
+        await it('a placement this renderer has no destination for is refused BY NAME', () => {
+            expect(() =>
+                mountSharedTree({ tag: 'AdwToolbarView', children: [{ tag: 'AdwBanner', slot: 'middle' }] }),
+            ).toThrow('has no slot "middle"');
+        });
+
+        // `child: Gtk.Label {…}` in a `.blp` authors `slot: 'child'` — the widget's own
+        // GObject property name — for every single-child widget the corpus never places
+        // one on. `<adw-clamp>` has no separate box to route into (every child is already
+        // the placement, clamped in place), which is why it took no `bindSlottedChildren`
+        // call at all until this slot needed one — and why it stayed unnoticed: the corpus
+        // above authors zero placements on it.
+        await it("AdwClamp accepts its GIR child property, 'child', as a named slot", () => {
+            mounted(
+                { tag: 'AdwClamp', children: [{ tag: 'GtkLabel', slot: 'child', props: { label: 'Clamped' } }] },
+                (root) => {
+                    expect(root.querySelector('gtk-label')?.getAttribute('label')).toBe('Clamped');
+                },
+            );
+        });
+
+        await it("AdwStatusPage accepts its GIR child property, 'child', as a named slot", () => {
+            mounted(
+                { tag: 'AdwStatusPage', children: [{ tag: 'GtkButton', slot: 'child', props: { label: 'Retry' } }] },
+                (root) => {
+                    expect(root.querySelector('.adw-status-page-child gtk-button')?.getAttribute('label')).toBe(
+                        'Retry',
+                    );
+                },
+            );
+        });
+
+        await it('the PROPERTY spelling of the title slot reaches the centre', () => {
+            // `title-widget:` is what a Blueprint source writes the centre at, and this
+            // element spells its own centre `center`; naming both is the element's own
+            // declaration, not a table in the builder.
+            //
+            // READ BY THE AUTHORED VALUE, not by the tag: an unrouted child is destroyed by
+            // the bar's own `replaceChildren`, and the bar then DERIVES an `<adw-window-title>`
+            // into the same centre — so a test asking only where an `<adw-window-title>` sits
+            // passed against the derived one with the authored one gone. Measured, by dropping
+            // the builder's `slot=` write: green.
+            const authored = { tag: 'AdwWindowTitle', slot: 'title-widget', props: { title: 'Placed' } };
+            mounted({ tag: 'AdwHeaderBar', children: [authored] }, (root) => {
+                const title = root.querySelector('adw-window-title[title="Placed"]');
+
+                expect(title?.parentElement?.className).toBe('adw-header-bar-center');
+            });
+        });
+    });
+
     await describe('the shared corpus against the adwaita-core vectors it reaches', async () => {
         for (const block of ADWAITA_GALLERY_SHARED_TREES) {
             for (const expectation of sharedTreeExpectations(block.root)) {

package/src/source-view/adw-source-view.ts

@@ -33,7 +33,7 @@ import { defaultKeymap, history, historyKeymap } from '@codemirror/commands';
 
 import { asm6502 } from './asm6502.js';
 import { adwaitaEditorTheme, adwaitaHighlightStyle, ensureSourceViewStyleInjected } from './theme.js';
-import { formatHexAddress, formatLineNumber, stripWhitespace } from './hex.js';
+import { formatHexAddress, formatLineNumber, stripSourceWhitespace } from '@gjsify/adwaita-core';
 import { createGtkImage } from '../elements/gtk-image.js';
 
 /** A recognisable copy glyph rendered inline so the subpath needs no icon CSS. */
@@ -379,7 +379,7 @@ export class AdwSourceView extends HTMLElement {
                 const { from, to } = view.state.selection.main;
                 if (from === to) return false;
                 const selected = view.state.sliceDoc(from, to);
-                event.clipboardData?.setData('text/plain', stripWhitespace(selected));
+                event.clipboardData?.setData('text/plain', stripSourceWhitespace(selected));
                 event.preventDefault();
                 return true;
             },
@@ -391,7 +391,7 @@ export class AdwSourceView extends HTMLElement {
     }
 
     private _onCopyButtonClick(): void {
-        const text = this._hexAddresses ? stripWhitespace(this.code) : this.code;
+        const text = this._hexAddresses ? stripSourceWhitespace(this.code) : this.code;
         const clipboard = (globalThis.navigator as Navigator | undefined)?.clipboard;
         if (clipboard?.writeText) void clipboard.writeText(text).catch(() => undefined);
         this.dispatchEvent(new CustomEvent('copy', { bubbles: true, detail: { code: this.code } }));

package/src/source-view/asm6502.ts

@@ -1,8 +1,14 @@
-// A CodeMirror 6 StreamLanguage mode for 6502 assembly — the web twin of the
+// The CodeMirror 6 binding for the 6502 assembly mode — the web twin of the
 // GtkSourceView `6502-assembler` language definition. A stream tokenizer is
 // enough here: 6502 asm is line-oriented and needs no nested grammar, so we
 // avoid a full Lezer grammar (per the task brief).
 //
+// The LANGUAGE itself — the opcode/register/directive tables and the tokenizer —
+// is not here. It lives in `@gjsify/adwaita-core` (`source.ts`), typed on an
+// eight-member stream interface that CodeMirror's `StringStream` satisfies
+// structurally, so a second renderer can highlight 6502 without CodeMirror and
+// this file stays what it claims to be: a binding.
+//
 // Token classes (mapped to @lezer/highlight tags via `asm6502TokenTable`):
 //   opcode     — the 56 official mnemonics (LDA, STA, JMP, …)      → keyword
 //   register   — the accumulator/index registers A, X, Y           → atom
@@ -13,197 +19,11 @@
 //   label      — a definition (`loop:` or a bare name at column 0) → labelName
 //   operator   — the immediate `#`, arithmetic + addressing punct  → operator
 //   identifier — any other symbol reference (a named operand)      → variableName
-//
-// Reference: refs/gjs-guide + the GtkSourceView `.lang` grammar shape.
 
-import { StreamLanguage, type StreamParser, type StringStream } from '@codemirror/language';
+import { StreamLanguage, type StreamParser } from '@codemirror/language';
 import { type Extension } from '@codemirror/state';
 import { tags, type Tag } from '@lezer/highlight';
-
-/** The 56 official NMOS 6502 mnemonics (uppercased for case-insensitive match). */
-export const OPCODES: ReadonlySet<string> = new Set([
-    'ADC',
-    'AND',
-    'ASL',
-    'BCC',
-    'BCS',
-    'BEQ',
-    'BIT',
-    'BMI',
-    'BNE',
-    'BPL',
-    'BRK',
-    'BVC',
-    'BVS',
-    'CLC',
-    'CLD',
-    'CLI',
-    'CLV',
-    'CMP',
-    'CPX',
-    'CPY',
-    'DEC',
-    'DEX',
-    'DEY',
-    'EOR',
-    'INC',
-    'INX',
-    'INY',
-    'JMP',
-    'JSR',
-    'LDA',
-    'LDX',
-    'LDY',
-    'LSR',
-    'NOP',
-    'ORA',
-    'PHA',
-    'PHP',
-    'PLA',
-    'PLP',
-    'ROL',
-    'ROR',
-    'RTI',
-    'RTS',
-    'SBC',
-    'SEC',
-    'SED',
-    'SEI',
-    'STA',
-    'STX',
-    'STY',
-    'TAX',
-    'TAY',
-    'TSX',
-    'TXA',
-    'TXS',
-    'TYA',
-]);
-
-/** The registers that appear as bare operands (`ASL A`, `LDA $00,X`). */
-export const REGISTERS: ReadonlySet<string> = new Set(['A', 'X', 'Y']);
-
-/** Assembler pseudo-ops. `define`/`dcb` are the easy6502 dialect; the rest are
- *  common cross-assembler directives (with the leading dot handled separately). */
-export const DIRECTIVE_WORDS: ReadonlySet<string> = new Set([
-    'DEFINE',
-    'DCB',
-    'ORG',
-    'BYTE',
-    'WORD',
-    'DB',
-    'DW',
-    'DS',
-    'ASCII',
-    'ASCIIZ',
-    'TEXT',
-    'INCLUDE',
-    'INCBIN',
-    'EQU',
-    'END',
-    'PROC',
-    'ENDPROC',
-    'MACRO',
-    'ENDMACRO',
-]);
-
-/**
- * Classify an identifier-shaped token. Pure + side-effect-free so it is unit
- * testable without a CodeMirror stream. `atLineStart` decides whether an
- * unknown word is a label DEFINITION (column 0) or a symbol REFERENCE.
- */
-export function classifyWord(word: string, atLineStart: boolean): string {
-    const upper = word.toUpperCase();
-    if (OPCODES.has(upper)) return 'opcode';
-    if (DIRECTIVE_WORDS.has(upper)) return 'directive';
-    if (REGISTERS.has(upper)) return 'register';
-    if (atLineStart) return 'label';
-    return 'identifier';
-}
-
-/**
- * Tokenize one token from the stream. Exported for unit tests (feed it a
- * `StringStream`). Returns a token-class name (see file header) or `null` for
- * whitespace/unclassified punctuation.
- */
-export function token6502(stream: StringStream): string | null {
-    const atLineStart = stream.sol();
-    if (stream.eatSpace()) return null;
-
-    const ch = stream.peek();
-    if (ch === null || ch === undefined) return null;
-
-    // `; …` line comment.
-    if (ch === ';') {
-        stream.skipToEnd();
-        return 'comment';
-    }
-
-    // Quoted string (used by `.ascii "…"` / `.byte "…"`).
-    if (ch === '"' || ch === "'") {
-        const quote = ch;
-        stream.next();
-        let escaped = false;
-        while (!stream.eol()) {
-            const c = stream.next();
-            if (c === undefined) break;
-            if (c === quote && !escaped) break;
-            escaped = c === '\\' && !escaped;
-        }
-        return 'string';
-    }
-
-    // Immediate-addressing prefix.
-    if (ch === '#') {
-        stream.next();
-        return 'operator';
-    }
-
-    // Hex literal `$1a2b`.
-    if (ch === '$') {
-        stream.next();
-        stream.eatWhile(/[0-9a-fA-F]/);
-        return 'number';
-    }
-
-    // Binary literal `%1010`.
-    if (ch === '%') {
-        stream.next();
-        stream.eatWhile(/[01]/);
-        return 'number';
-    }
-
-    // Decimal literal.
-    if (/[0-9]/.test(ch)) {
-        stream.eatWhile(/[0-9]/);
-        return 'number';
-    }
-
-    // Dot-directive `.org` / `.byte`.
-    if (ch === '.') {
-        stream.next();
-        if (stream.eatWhile(/[A-Za-z0-9_]/)) return 'directive';
-        return null;
-    }
-
-    // Identifier → opcode / register / directive / label / reference.
-    if (/[A-Za-z_]/.test(ch)) {
-        stream.eatWhile(/[A-Za-z0-9_]/);
-        const word = stream.current();
-        // An explicit `name:` is always a label definition.
-        if (stream.peek() === ':') return 'label';
-        return classifyWord(word, atLineStart);
-    }
-
-    // Arithmetic / addressing punctuation.
-    if ('+-*/=<>,()[]&|^~'.includes(ch)) {
-        stream.next();
-        return 'operator';
-    }
-
-    stream.next();
-    return null;
-}
+import { ADW_SOURCE_6502_LINE_COMMENT, tokenizeAsm6502 } from '@gjsify/adwaita-core';
 
 /** Maps this mode's token-class names to @lezer/highlight tags. */
 export const asm6502TokenTable: Record<string, Tag> = {
@@ -221,9 +41,9 @@ export const asm6502TokenTable: Record<string, Tag> = {
 /** The StreamParser powering the 6502 mode. */
 export const asm6502Parser: StreamParser<unknown> = {
     name: '6502',
-    token: (stream) => token6502(stream),
+    token: (stream) => tokenizeAsm6502(stream),
     tokenTable: asm6502TokenTable,
-    languageData: { commentTokens: { line: ';' } },
+    languageData: { commentTokens: { line: ADW_SOURCE_6502_LINE_COMMENT } },
 };
 
 /** The 6502 assembly language extension for a CodeMirror EditorState. */

package/src/source-view/index.ts

@@ -8,16 +8,7 @@ export { AdwSourceView } from './adw-source-view.js';
 
 // Building blocks, exported so apps/tests can reuse them (e.g. embed the 6502
 // mode or the Adwaita theme in a bespoke EditorView).
-export {
-    asm6502,
-    asm6502Parser,
-    asm6502TokenTable,
-    classifyWord,
-    token6502,
-    OPCODES,
-    REGISTERS,
-    DIRECTIVE_WORDS,
-} from './asm6502.js';
+export { asm6502, asm6502Parser, asm6502TokenTable } from './asm6502.js';
 export {
     adwaitaEditorTheme,
     adwaitaHighlightStyle,
@@ -25,4 +16,19 @@ export {
     SOURCE_VIEW_CSS,
     SOURCE_VIEW_STYLE_ID,
 } from './theme.js';
-export { formatHexAddress, formatLineNumber, stripWhitespace, HEX_ADDRESS_STRIDE } from './hex.js';
+
+// The renderer-free half — language tables, tokenizer, gutter formatters — is
+// owned by `@gjsify/adwaita-core`. Re-exported here under the spellings this
+// subpath has always published, so nothing that imports them has to move.
+export {
+    ADW_SOURCE_6502_DIRECTIVES as DIRECTIVE_WORDS,
+    ADW_SOURCE_6502_OPCODES as OPCODES,
+    ADW_SOURCE_6502_REGISTERS as REGISTERS,
+    ADW_SOURCE_HEX_STRIDE as HEX_ADDRESS_STRIDE,
+    classifyAsm6502Word as classifyWord,
+    formatHexAddress,
+    formatLineNumber,
+    stripSourceWhitespace as stripWhitespace,
+    tokenizeAsm6502 as token6502,
+} from '@gjsify/adwaita-core';
+export type { AdwSourceTokenClass, AdwSourceTokenStream } from '@gjsify/adwaita-core';