@lokascript/framework 2.8.0 → 2.9.1

package/src/api/extensions.test.ts

@@ -0,0 +1,322 @@
+/**
+ * DomainExtension: adding a command to a DSL from outside its package.
+ *
+ * Every domain used to render through a hardcoded `switch (node.action)` and
+ * generate through another, so a downstream consumer could not add a command
+ * without editing the package. This is the supported path: a schema plus one
+ * vocabulary entry per language.
+ *
+ * The command exercised here ("research") is the one lokascript-learn built by
+ * hand against 2.8.0 to prove the underlying pieces worked.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  createMultilingualDSL,
+  createSimpleTokenizer,
+  defineCommand,
+  defineRole,
+  type DomainExtension,
+  type ExtractionResult,
+  type LanguageTokenizer,
+  type SemanticNode,
+  type ValueExtractor,
+} from '../index';
+
+/**
+ * Keeps `#id` / `.class` a single token, as every real domain tokenizer does.
+ * Without it the `#` splits off and an SOV source role followed by a particle
+ * never matches.
+ */
+class CSSSelectorExtractor implements ValueExtractor {
+  readonly name = 'css-selector';
+
+  canExtract(input: string, position: number): boolean {
+    const char = input[position];
+    if (char !== '#' && char !== '.') return false;
+    return /[a-zA-Z_-]/.test(input[position + 1] ?? '');
+  }
+
+  extract(input: string, position: number): ExtractionResult | null {
+    let end = position + 1;
+    while (end < input.length && /[a-zA-Z0-9_-]/.test(input[end])) end++;
+    if (end === position + 1) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+}
+
+// =============================================================================
+// A three-word-order toy DSL
+// =============================================================================
+
+const askSchema = defineCommand({
+  action: 'ask',
+  description: 'Ask a question',
+  category: 'llm',
+  primaryRole: 'patient',
+  roles: [
+    defineRole({
+      role: 'patient',
+      description: 'The question',
+      required: true,
+      expectedTypes: ['expression'],
+    }),
+    defineRole({
+      role: 'source',
+      description: 'Where to look',
+      required: true,
+      expectedTypes: ['expression'],
+      markerOverride: { en: 'from', ja: 'から', ar: 'من' },
+    }),
+  ],
+});
+
+const researchSchema = defineCommand({
+  action: 'research',
+  description: 'Research a topic',
+  category: 'llm',
+  primaryRole: 'patient',
+  roles: [
+    defineRole({
+      role: 'patient',
+      description: 'The topic',
+      required: true,
+      expectedTypes: ['expression'],
+    }),
+    defineRole({
+      role: 'source',
+      description: 'Where to look',
+      required: true,
+      expectedTypes: ['expression'],
+      markerOverride: { en: 'from', ja: 'から', ar: 'من' },
+    }),
+  ],
+});
+
+const PROFILES = {
+  en: {
+    code: 'en',
+    wordOrder: 'SVO' as const,
+    keywords: { ask: { primary: 'ask' } },
+    roleMarkers: {},
+  },
+  ja: {
+    code: 'ja',
+    wordOrder: 'SOV' as const,
+    keywords: { ask: { primary: '聞く' } },
+    roleMarkers: {},
+  },
+  ar: {
+    code: 'ar',
+    wordOrder: 'VSO' as const,
+    keywords: { ask: { primary: 'اسأل' } },
+    roleMarkers: {},
+  },
+};
+
+const research: DomainExtension = {
+  schema: researchSchema,
+  vocabulary: {
+    en: { keyword: { primary: 'research' } },
+    ja: { keyword: { primary: '調査' } },
+    ar: { keyword: { primary: 'ابحث' } },
+  },
+};
+
+function tokenizerFor(code: 'en' | 'ja' | 'ar'): LanguageTokenizer {
+  return createSimpleTokenizer({
+    language: code,
+    // Both the built-in and the extension vocabulary: a tokenizer is configured
+    // once, so it must already know the words an extension may introduce.
+    keywords: [
+      ...Object.values(PROFILES[code].keywords).map(k => k.primary),
+      'research',
+      '調査',
+      'ابحث',
+      'from',
+      'から',
+      'من',
+    ],
+    caseInsensitive: code === 'en',
+    customExtractors: [new CSSSelectorExtractor()],
+  });
+}
+
+function createToyDSL(options: { extensions?: readonly DomainExtension[] } = {}) {
+  return createMultilingualDSL({
+    name: 'Toy',
+    schemas: [askSchema],
+    languages: (['en', 'ja', 'ar'] as const).map(code => ({
+      code,
+      name: code,
+      nativeName: code,
+      tokenizer: tokenizerFor(code),
+      patternProfile: PROFILES[code],
+    })),
+    codeGenerator: {
+      generate: (node: SemanticNode) => `BASE:${node.action}`,
+    },
+    ...(options.extensions && { extensions: options.extensions }),
+  });
+}
+
+function makeNode(action: string, roles: Record<string, string>): SemanticNode {
+  const rolesMap = new Map<string, { type: 'expression'; raw: string }>();
+  for (const [k, v] of Object.entries(roles)) rolesMap.set(k, { type: 'expression', raw: v });
+  return { kind: 'command', action, roles: rolesMap };
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('DomainExtension', () => {
+  describe('parsing', () => {
+    it('parses the extension command in an SVO language', () => {
+      const dsl = createToyDSL({ extensions: [research] });
+      const node = dsl.parse('research "climate" from #wiki', 'en');
+      expect(node.action).toBe('research');
+      expect(node.roles.get('patient')).toBeDefined();
+      expect(node.roles.get('source')).toBeDefined();
+    });
+
+    it('parses the extension command in an SOV language', () => {
+      const dsl = createToyDSL({ extensions: [research] });
+      const node = dsl.parse('"climate" #wiki から 調査', 'ja');
+      expect(node.action).toBe('research');
+    });
+
+    it('parses the extension command in a VSO language', () => {
+      const dsl = createToyDSL({ extensions: [research] });
+      const node = dsl.parse('ابحث "climate" من #wiki', 'ar');
+      expect(node.action).toBe('research');
+    });
+
+    it('does not parse the extension command without the extension', () => {
+      const dsl = createToyDSL();
+      expect(() => dsl.parse('research "climate" from #wiki', 'en')).toThrow(/No pattern matched/);
+    });
+
+    it('reports the extension action as supported by explicit syntax', () => {
+      const dsl = createToyDSL({ extensions: [research] });
+      const node = dsl.parse('[research patient:climate source:#wiki]', 'en');
+      expect(node.action).toBe('research');
+    });
+  });
+
+  describe('rendering', () => {
+    const dsl = createToyDSL({ extensions: [research] });
+    const node = makeNode('research', { patient: '"climate"', source: '#wiki' });
+
+    it('renders SVO from the schema alone', () => {
+      expect(dsl.render?.(node, 'en')).toBe('research "climate" from #wiki');
+    });
+
+    it('renders verb-final for SOV', () => {
+      expect(dsl.render?.(node, 'ja')).toBe('"climate" #wiki から 調査');
+    });
+
+    it('renders verb-initial for VSO', () => {
+      expect(dsl.render?.(node, 'ar')).toBe('ابحث "climate" من #wiki');
+    });
+
+    it('prefers an extension-supplied renderer', () => {
+      const custom = createToyDSL({
+        extensions: [{ ...research, render: () => 'CUSTOM' }],
+      });
+      expect(custom.render?.(node, 'en')).toBe('CUSTOM');
+    });
+
+    it('returns null for an action with neither renderer nor schema', () => {
+      expect(dsl.render?.(makeNode('nonsense', {}), 'en')).toBeNull();
+    });
+
+    it('prefers the domain renderer over the schema fallback for built-ins', () => {
+      const withDomainRenderer = createMultilingualDSL({
+        name: 'Toy',
+        schemas: [askSchema],
+        languages: [
+          {
+            code: 'en',
+            name: 'en',
+            nativeName: 'en',
+            tokenizer: tokenizerFor('en'),
+            patternProfile: PROFILES.en,
+          },
+        ],
+        renderer: node => (node.action === 'ask' ? 'DOMAIN RENDERED' : null),
+        extensions: [{ ...research, vocabulary: { en: research.vocabulary.en } }],
+      });
+
+      expect(withDomainRenderer.render?.(makeNode('ask', { patient: 'q' }), 'en')).toBe(
+        'DOMAIN RENDERED'
+      );
+      // …while the extension still falls through to the schema renderer
+      expect(withDomainRenderer.render?.(node, 'en')).toBe('research "climate" from #wiki');
+    });
+  });
+
+  describe('compilation', () => {
+    it('uses the extension generator for the extension action', () => {
+      const dsl = createToyDSL({
+        extensions: [{ ...research, generate: node => `EXT:${node.action}` }],
+      });
+      const result = dsl.compile('research "climate" from #wiki', 'en');
+      expect(result.ok).toBe(true);
+      expect(result.code).toBe('EXT:research');
+    });
+
+    it('leaves the base generator handling built-in actions', () => {
+      const dsl = createToyDSL({
+        extensions: [{ ...research, generate: node => `EXT:${node.action}` }],
+      });
+      const result = dsl.compile('ask "q" from #wiki', 'en');
+      expect(result.ok).toBe(true);
+      expect(result.code).toBe('BASE:ask');
+    });
+
+    it('falls back to the base generator when the extension supplies none', () => {
+      const dsl = createToyDSL({ extensions: [research] });
+      const result = dsl.compile('research "climate" from #wiki', 'en');
+      expect(result.ok).toBe(true);
+      expect(result.code).toBe('BASE:research');
+    });
+  });
+
+  describe('built-in commands are unaffected', () => {
+    it('parses and compiles identically with and without extensions', () => {
+      const plain = createToyDSL();
+      const extended = createToyDSL({ extensions: [research] });
+
+      for (const [input, language] of [
+        ['ask "q" from #wiki', 'en'],
+        ['"q" #wiki から 聞く', 'ja'],
+        ['اسأل "q" من #wiki', 'ar'],
+      ] as const) {
+        expect(extended.parse(input, language).action).toBe(plain.parse(input, language).action);
+        expect(extended.compile(input, language).code).toBe(plain.compile(input, language).code);
+      }
+    });
+  });
+
+  describe('configuration errors', () => {
+    it('rejects an extension whose action collides with a built-in', () => {
+      const collision: DomainExtension = {
+        schema: defineCommand({
+          action: 'ask',
+          roles: [defineRole({ role: 'patient', required: true, expectedTypes: ['expression'] })],
+        }),
+        vocabulary: { en: { keyword: { primary: 'inquire' } } },
+      };
+      expect(() => createToyDSL({ extensions: [collision] })).toThrow(/collides/);
+    });
+
+    it('rejects vocabulary for a language the DSL does not configure', () => {
+      const unknownLanguage: DomainExtension = {
+        ...research,
+        vocabulary: { ...research.vocabulary, xx: { keyword: { primary: 'x' } } },
+      };
+      expect(() => createToyDSL({ extensions: [unknownLanguage] })).toThrow(/not configured/);
+    });
+  });
+});

package/src/core/tokenization/base-tokenizer.ts

@@ -20,6 +20,7 @@ import {
   isWhitespace,
   isDigit,
   isAsciiIdentifierChar,
+  stripOptionalDiacritics,
   TokenStreamImpl,
   type TimeUnitMapping,
   type CreateTokenOptions,
@@ -598,9 +599,7 @@ export abstract class BaseTokenizer implements LanguageTokenizer {
    * @returns Word without diacritics
    */
   protected removeDiacritics(word: string): string {
-    // Arabic diacritics: U+064B-U+0652 (fatha, kasra, damma, sukun, shadda, etc.)
-    // U+0670 (superscript alif)
-    return word.replace(/[\u064B-\u0652\u0670]/g, '');
+    return stripOptionalDiacritics(word);
   }
 
   /**
@@ -704,25 +703,41 @@ export abstract class BaseTokenizer implements LanguageTokenizer {
   }
 
   /**
-   * Look up a keyword by native word (case-insensitive).
+   * Look up a keyword by native word (case-insensitive, diacritic-insensitive).
    * O(1) lookup using the keyword map.
    *
+   * The map is INDEXED both with and without diacritics (see
+   * `initializeKeywordsFromProfile`), so a stripped QUERY is the other half of
+   * that: it lets a surface form carrying harakat the profile does not happen to
+   * spell still find its entry. Only consulted after the exact lookup misses, so
+   * every previously-matching word resolves byte-identically.
+   *
+   * Half-implementing this — indexing stripped but querying exact — is what made
+   * diacritized `بَدِّل` (toggle) tokenize as `kind=particle normalized=with`:
+   * `isKeyword` returned false, so the guard in `ArabicProcliticExtractor` that
+   * exists to prevent exactly that handed the word on, and the single-char `ب`
+   * bi- proclitic claimed it. A wrong CONCEPT, not a failed parse.
+   *
    * @param native - Native word to look up
    * @returns KeywordEntry if found, undefined otherwise
    */
   protected lookupKeyword(native: string): KeywordEntry | undefined {
-    return this.profileKeywordMap.get(native.toLowerCase());
+    const exact = this.profileKeywordMap.get(native.toLowerCase());
+    if (exact) return exact;
+    const stripped = this.removeDiacritics(native);
+    if (stripped === native) return undefined;
+    return this.profileKeywordMap.get(stripped.toLowerCase());
   }
 
   /**
-   * Check if a word is a known keyword (case-insensitive).
-   * O(1) lookup using the keyword map.
+   * Check if a word is a known keyword (case-insensitive, diacritic-insensitive).
+   * O(1) lookup using the keyword map. See {@link lookupKeyword}.
    *
    * @param native - Native word to check
    * @returns true if the word is a keyword
    */
   protected isKeyword(native: string): boolean {
-    return this.profileKeywordMap.has(native.toLowerCase());
+    return this.lookupKeyword(native) !== undefined;
   }
 
   /**

package/src/core/tokenization/char-classifiers.ts

@@ -67,10 +67,10 @@ export interface LatinCharClassifiers {
  *
  * @example
  * // Spanish letters
- * const { isLetter, isIdentifierChar } = createLatinCharClassifiers(/[a-zA-ZáéíóúüñÁÉÍÓÚÜÑ]/);
+ * const { isLetter, isIdentifierChar } = createLatinCharClassifiers(/[a-zA-Z\u00e1\u00e9\u00ed\u00f3\u00fa\u00fc\u00f1\u00c1\u00c9\u00cd\u00d3\u00da\u00dc\u00d1]/);
  *
  * // German letters
- * const { isLetter, isIdentifierChar } = createLatinCharClassifiers(/[a-zA-ZäöüÄÖÜß]/);
+ * const { isLetter, isIdentifierChar } = createLatinCharClassifiers(/[a-zA-Z\u00e4\u00f6\u00fc\u00c4\u00d6\u00dc\u00df]/);
  */
 export function createLatinCharClassifiers(letterPattern: RegExp): LatinCharClassifiers {
   const isLetter = (char: string): boolean => letterPattern.test(char);

package/src/core/tokenization/css-selector-extractor.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { CssSelectorExtractor } from '../../interfaces/value-extractor';
+
+/**
+ * `getDefaultExtractors()` has no CSS-selector extractor, so a DSL that does not
+ * register one splits the sigil off as its own token and the role capture keeps
+ * only that sigil — `add .active to #button` parsed with patient `"."` and
+ * destination `"#"` in domain-learn, -todo, -sql and -jsx, silently, in every
+ * language. Five other domains each carried a private copy of this class; this
+ * is the shared one.
+ */
+describe('CssSelectorExtractor', () => {
+  const ex = new CssSelectorExtractor();
+
+  const extract = (input: string, pos = 0) =>
+    ex.canExtract(input, pos) ? ex.extract(input, pos) : null;
+
+  it.each([
+    ['.active', '.active'],
+    ['#button', '#button'],
+    ['.btn-primary', '.btn-primary'],
+    ['._private', '._private'],
+    ['#a1', '#a1'],
+    ['.-leading-hyphen', '.-leading-hyphen'],
+  ])('extracts %s whole', (input, expected) => {
+    expect(extract(input)).toEqual({ value: expected, length: expected.length });
+  });
+
+  it('stops at the first character that cannot be in a selector', () => {
+    expect(extract('.active to #button')).toEqual({ value: '.active', length: 7 });
+  });
+
+  it('keeps diacritics, so Latin-script class names survive', () => {
+    expect(extract('.año')).toEqual({ value: '.año', length: 4 });
+    expect(extract('#botón')).toEqual({ value: '#botón', length: 6 });
+  });
+
+  // The SOV languages write their particles flush against the value, so a
+  // Unicode-wide body turns `#buttonに` into a single token and carries the role
+  // marker inside the value — which is worse than truncating, because the marker
+  // is then missing from where the pattern expects it.
+  it.each([
+    ['#buttonに', '#button'],
+    ['.activeを', '.active'],
+    ['#button에', '#button'],
+    ['.active를', '.active'],
+    ['#button的', '#button'],
+  ])('stops at the particle in %s', (input, expected) => {
+    expect(extract(input)).toEqual({ value: expected, length: expected.length });
+  });
+
+  it.each([
+    ['.', 'a bare sigil'],
+    ['#', 'a bare sigil'],
+    ['. active', 'a sigil followed by a space'],
+    ['.1col', 'a digit — CSS identifiers cannot start with one'],
+    ['button', 'no sigil at all'],
+  ])('declines %s (%s)', input => {
+    expect(ex.canExtract(input, 0)).toBe(false);
+  });
+
+  it('declines a CJK-only class name rather than claiming the sigil alone', () => {
+    // `.追加` would otherwise extract as a bare `.`; leaving it unclaimed lets
+    // the keyword/identifier extractors see the verb.
+    expect(ex.canExtract('.追加', 0)).toBe(false);
+  });
+});

package/src/core/tokenization/token-utils.ts

@@ -237,6 +237,24 @@ export function isDigit(char: string): boolean {
   return /\d/.test(char);
 }
 
+/**
+ * Strip diacritical marks that are OPTIONAL in their script — currently Arabic
+ * harakat (U+064B–U+0652: fatha, kasra, damma, sukun, shadda…) and the
+ * superscript alif (U+0670).
+ *
+ * `بدّل` and `بَدِّل` are the same word; Arabic prose writes either. So any place
+ * that compares an Arabic surface form against a declared keyword has to compare
+ * stripped, or the same word fails to match itself.
+ *
+ * Deliberately Arabic-only. Latin diacritics are NOT optional — `obtén`, `récupère`
+ * and `vá` differ from their unaccented spellings in meaning or validity — and
+ * Hebrew niqqud (U+05B0–U+05BC) is out of range too, so this is inert for every
+ * other script.
+ */
+export function stripOptionalDiacritics(word: string): string {
+  return word.replace(/[\u064b-\u0652\u0670]/g, '');
+}
+
 /**
  * Check if a character is an ASCII letter.
  */

package/src/generation/domain-renderer.test.ts

@@ -0,0 +1,172 @@
+/**
+ * createDomainRenderer: hand-written overrides + schema fallthrough + null.
+ *
+ * Domains used to render through a hardcoded `switch (node.action)` whose
+ * default returned a sentinel string (`-- Unknown: <action>`), so a downstream
+ * consumer could neither add a command nor distinguish failure from success
+ * without string matching. This composes the two halves instead.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { createDomainRenderer, createSchemaRenderer } from './renderer';
+import type { SemanticNode } from '../core/types';
+import type { CommandSchema } from '../schema';
+import { defineCommand, defineRole } from '../schema';
+import type { PatternGenLanguageProfile } from './pattern-generator';
+
+function makeNode(action: string, roles: Record<string, string>): SemanticNode {
+  const rolesMap = new Map<string, { type: 'expression'; raw: string }>();
+  for (const [k, v] of Object.entries(roles)) {
+    rolesMap.set(k, { type: 'expression', raw: v });
+  }
+  return { kind: 'command', action, roles: rolesMap };
+}
+
+const selectSchema = defineCommand({
+  action: 'select',
+  description: 'Select data',
+  category: 'query',
+  primaryRole: 'columns',
+  roles: [
+    defineRole({ role: 'columns', required: true, expectedTypes: ['expression'] }),
+    defineRole({
+      role: 'source',
+      required: true,
+      expectedTypes: ['expression'],
+      markerOverride: { en: 'from', ja: 'から', ar: 'من' },
+    }),
+  ],
+});
+
+/** Stands in for a command a downstream consumer added without editing the domain. */
+const researchSchema = defineCommand({
+  action: 'research',
+  description: 'Research a topic',
+  category: 'query',
+  primaryRole: 'patient',
+  roles: [
+    defineRole({ role: 'patient', required: true, expectedTypes: ['expression'] }),
+    defineRole({
+      role: 'source',
+      required: true,
+      expectedTypes: ['expression'],
+      markerOverride: { en: 'from', ja: 'から', ar: 'من' },
+    }),
+  ],
+});
+
+const profiles: PatternGenLanguageProfile[] = [
+  {
+    code: 'en',
+    wordOrder: 'SVO',
+    keywords: { select: { primary: 'select' }, research: { primary: 'research' } },
+    roleMarkers: {},
+  },
+  {
+    code: 'ja',
+    wordOrder: 'SOV',
+    keywords: { select: { primary: '選択' }, research: { primary: '調査' } },
+    roleMarkers: {},
+  },
+  {
+    code: 'ar',
+    wordOrder: 'VSO',
+    keywords: { select: { primary: 'اختر' }, research: { primary: 'ابحث' } },
+    roleMarkers: {},
+  },
+];
+
+const schemas: CommandSchema[] = [selectSchema, researchSchema];
+
+describe('createDomainRenderer', () => {
+  describe('overrides take precedence', () => {
+    it('uses the hand-written renderer for an action it covers', () => {
+      const render = createDomainRenderer({
+        schemas,
+        profiles,
+        overrides: { select: () => 'HAND WRITTEN' },
+      });
+      expect(render(makeNode('select', { columns: 'name', source: 'users' }), 'en')).toBe(
+        'HAND WRITTEN'
+      );
+    });
+
+    it('passes the node and language through to the override', () => {
+      const override = vi.fn(() => 'x');
+      const render = createDomainRenderer({ schemas, profiles, overrides: { select: override } });
+      const node = makeNode('select', { columns: 'name', source: 'users' });
+
+      render(node, 'ja');
+
+      expect(override).toHaveBeenCalledWith(node, 'ja');
+    });
+  });
+
+  describe('schema fallthrough', () => {
+    // These are the outputs a downstream consumer gets for a command the domain
+    // package has never heard of — the whole point of the fallthrough.
+    const render = createDomainRenderer({
+      schemas,
+      profiles,
+      overrides: { select: () => 'HAND WRITTEN' },
+    });
+    const node = makeNode('research', { patient: '"climate"', source: '#wiki' });
+
+    it('renders SVO', () => {
+      expect(render(node, 'en')).toBe('research "climate" from #wiki');
+    });
+
+    it('renders verb-final for SOV', () => {
+      expect(render(node, 'ja')).toBe('"climate" #wiki から 調査');
+    });
+
+    it('renders verb-initial for VSO', () => {
+      expect(render(node, 'ar')).toBe('ابحث "climate" من #wiki');
+    });
+
+    it('matches createSchemaRenderer for the same schema', () => {
+      const schemaRenderer = createSchemaRenderer(schemas, profiles);
+      for (const language of ['en', 'ja', 'ar']) {
+        expect(render(node, language)).toBe(schemaRenderer.render(node, language));
+      }
+    });
+  });
+
+  describe('unknown actions', () => {
+    it('returns null rather than a sentinel string', () => {
+      const render = createDomainRenderer({ schemas, profiles });
+      expect(render(makeNode('nonsense', { patient: 'x' }), 'en')).toBeNull();
+    });
+
+    it('returns null even when other actions have overrides', () => {
+      const render = createDomainRenderer({
+        schemas,
+        profiles,
+        overrides: { select: () => 'HAND WRITTEN' },
+      });
+      expect(render(makeNode('nonsense', {}), 'ja')).toBeNull();
+    });
+  });
+
+  it('builds its tables lazily', () => {
+    // Constructing a renderer at module scope must not walk every schema and
+    // profile; domains create one per module whether or not it is ever called.
+    const profileAccess = vi.fn(() => 'SVO' as const);
+    const watchedProfiles = [
+      {
+        code: 'en',
+        keywords: { select: { primary: 'select' } },
+        roleMarkers: {},
+        get wordOrder() {
+          return profileAccess();
+        },
+      } as unknown as PatternGenLanguageProfile,
+    ];
+
+    const render = createDomainRenderer({ schemas, profiles: watchedProfiles });
+    expect(profileAccess).not.toHaveBeenCalled();
+
+    render(makeNode('select', { columns: 'name', source: 'users' }), 'en');
+    expect(profileAccess).toHaveBeenCalled();
+  });
+});