npm - devabhasha - Versions diffs - 1.0.0 - Mend

devabhasha 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/src/devserver.js ADDED Viewed

@@ -0,0 +1,148 @@
+// devserver.js — a zero-dependency dev server with live reload for .deva web
+// programs. Serves an HTML page that runs the compiled program, watches the
+// source (and its directory, catching आयात imports), recompiles on change, and
+// pushes a reload signal to the browser over Server-Sent Events. Compile errors
+// are shown on the page instead of a blank screen.
+//
+// Uses only Node built-ins (http, fs) — no external packages — so it runs in
+// the same dependency-free environment as the rest of the toolchain.
+import { createServer } from 'http';
+import { readFileSync, watch } from 'fs';
+import { dirname, basename } from 'path';
+import { bundle } from './bundler.js';
+import { DevabhashaError, formatError } from './errors.js';
+// Build the browser bundle for the entry file. Returns { ok, code | error }.
+function buildBundle(entry) {
+  try {
+    const code = bundle(entry, { includeRuntime: true });
+    return { ok: true, code };
+  } catch (e) {
+    const src = (() => { try { return readFileSync(entry, 'utf8'); } catch { return ''; } })();
+    const msg = e instanceof DevabhashaError ? formatError(e, e.source || src) : ('दोषः: ' + e.message);
+    return { ok: false, error: msg };
+  }
+}
+// The HTML shell. #मूलम् is the mount root; the live-reload client listens on
+// /__live (SSE) and reloads on the 'reload' event. A compile error is rendered
+// into the page (passed via a global the bundle replaces) rather than crashing.
+function pageHtml(entryName) {
+  return `<!DOCTYPE html>
+<html lang="sa">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${entryName} — देवभाषा</title>
+<style>
+  body { margin: 0; font-family: system-ui, -apple-system, sans-serif; background: #f4f1ea; }
+  #__err { white-space: pre-wrap; font-family: ui-monospace, monospace; color: #a33;
+           background: #fff5f5; border: 1px solid #f3c0c0; border-radius: 8px;
+           margin: 20px; padding: 16px 20px; font-size: 13px; }
+  #मूलम् { min-height: 100vh; }
+</style>
+</head>
+<body>
+<div id="मूलम्"></div>
+<script>
+  // live reload over Server-Sent Events
+  try {
+    const es = new EventSource('/__live');
+    es.addEventListener('reload', () => location.reload());
+  } catch (e) {}
+</script>
+<script src="/__bundle.js"></script>
+</body>
+</html>`;
+}
+// Wrap a compiled bundle so the DOM runtime mounts to #मूलम् by default and
+// any runtime error is shown on the page.
+function wrapBundle(code) {
+  return `(function(){
+  var __root = document.getElementById('मूलम्');
+  try {
+${code}
+  } catch (e) {
+    var d = document.createElement('div'); d.id = '__err';
+    d.textContent = 'दोषः (runtime): ' + (e && e.message || e);
+    document.body.appendChild(d);
+    console.error(e);
+  }
+})();`;
+}
+function errorPageScript(message) {
+  return `(function(){
+  var d = document.createElement('div'); d.id = '__err';
+  d.textContent = ${JSON.stringify(message)};
+  document.body.appendChild(d);
+})();`;
+}
+export function serve(entry, { port = 5173, open = false } = {}) {
+  const entryName = basename(entry);
+  const clients = new Set();           // open SSE responses
+  const server = createServer((req, res) => {
+    if (req.url === '/' || req.url === '/index.html') {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(pageHtml(entryName));
+      return;
+    }
+    if (req.url === '/__bundle.js') {
+      const built = buildBundle(entry);
+      res.writeHead(200, { 'Content-Type': 'application/javascript; charset=utf-8' });
+      res.end(built.ok ? wrapBundle(built.code) : errorPageScript(built.error));
+      return;
+    }
+    if (req.url === '/__live') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+      res.write('retry: 1000\n\n');
+      clients.add(res);
+      req.on('close', () => clients.delete(res));
+      return;
+    }
+    res.writeHead(404); res.end('not found');
+  });
+  function notifyReload() {
+    for (const res of clients) { try { res.write('event: reload\ndata: 1\n\n'); } catch {} }
+  }
+  // Watch the entry's directory so edits to it OR its imports trigger a reload.
+  // Debounced — editors often fire several events per save.
+  let timer = null;
+  const dir = dirname(entry) || '.';
+  let watcher = null;
+  try {
+    watcher = watch(dir, { persistent: true }, (_evt, fname) => {
+      if (fname && !/\.deva$/.test(fname)) return;   // only .deva changes
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        const built = buildBundle(entry);
+        console.log(built.ok ? `↻ recompiled ${entryName}` : `✗ ${entryName} has errors (shown in browser)`);
+        notifyReload();
+      }, 60);
+    });
+  } catch (e) {
+    console.error('चेतावनी: file watching unavailable — live reload disabled.');
+  }
+  server.listen(port, () => {
+    // initial build feedback
+    const built = buildBundle(entry);
+    if (!built.ok) console.log(`✗ ${entryName} has errors (shown in browser):\n` + built.error);
+    console.log(`\n  देवभाषा dev server\n  ▸ http://localhost:${port}/\n  watching ${entryName} for changes (live reload on)\n`);
+  });
+  return {
+    server,
+    close() { if (watcher) watcher.close(); for (const r of clients) { try { r.end(); } catch {} } server.close(); },
+  };
+}

package/src/errors.js ADDED Viewed

@@ -0,0 +1,71 @@
+// errors.js — structured compiler errors with source-context formatting.
+//
+// A good error shows WHERE the problem is, in the source, with a caret.
+// DevabhashaError carries the position; formatError renders the offending
+// line and points at the column:
+//
+//   दोषः (parse error): expected ')' but found ';'
+//     line 3, column 12
+//
+//     ३ | दर्शय(अ + ब;
+//       |           ^
+//
+// kind is a short tag ('lex' | 'parse' | 'codegen') used for the heading.
+export class DevabhashaError extends Error {
+  constructor(message, { line = null, col = null, kind = 'parse' } = {}) {
+    super(message);
+    this.name = 'DevabhashaError';
+    this.line = line;
+    this.col = col;
+    this.kind = kind;
+  }
+}
+const KIND_LABEL = {
+  lex: 'अक्षरदोषः (lex error)',
+  parse: 'पाठदोषः (parse error)',
+  codegen: 'कूटदोषः (codegen error)',
+  runtime: 'क्रियादोषः (runtime error)',
+};
+// Convert a Devanagari/ASCII digit line number into Devanagari for display.
+const DEVA_DIGITS = '०१२३४५६७८९';
+function toDeva(n) {
+  return String(n).split('').map(d => /[0-9]/.test(d) ? DEVA_DIGITS[+d] : d).join('');
+}
+// Render an error with source context. `source` is the original program text.
+export function formatError(err, source) {
+  const label = KIND_LABEL[err.kind] || 'दोषः (error)';
+  let out = `${label}: ${err.message}`;
+  if (err.line == null) return out;
+  out += `\n  line ${err.line}, column ${err.col ?? '?'}`;
+  if (source != null) {
+    const lines = source.split('\n');
+    const srcLine = lines[err.line - 1];
+    if (srcLine !== undefined) {
+      const gutter = toDeva(err.line);
+      const pad = ' '.repeat(gutter.length);
+      out += `\n\n  ${gutter} | ${srcLine}`;
+      if (err.col != null) {
+        // caret: account for the gutter and the column (1-based)
+        const caretPad = ' '.repeat(Math.max(0, err.col - 1));
+        out += `\n  ${pad} | ${caretPad}^`;
+      }
+    }
+  }
+  return out;
+}
+// Helper used by the lexer/parser to raise a positioned error.
+export function raise(message, pos, kind = 'parse') {
+  throw new DevabhashaError(message, {
+    line: pos && pos.line,
+    col: pos && pos.col,
+    kind,
+  });
+}

package/src/index.js ADDED Viewed

@@ -0,0 +1,30 @@
+// index.js — public API: compile(source) -> javascript string.
+import { tokenize } from './lexer.js';
+import { parse } from './parser.js';
+import { generate } from './codegen.js';
+export function compile(source, options = {}) {
+  const tokens = tokenize(source);
+  const ast = parse(tokens);
+  return generate(ast, options);
+}
+// Like compile, but returns { code, exports, imports } for the bundler.
+// Never includes the runtime (the bundler adds it once for the whole program).
+export function compileModule(source) {
+  const tokens = tokenize(source);
+  const ast = parse(tokens);
+  return generate(ast, { includeRuntime: false, withMeta: true });
+}
+// Like compile, but also returns a Source Map v3 object: { code, map }.
+export function compileWithMap(source, options = {}) {
+  const tokens = tokenize(source);
+  const ast = parse(tokens);
+  return generate(ast, { ...options, sourceMap: true });
+}
+export { tokenize, parse, generate };
+export { PRELUDE } from './codegen.js';
+export { DevabhashaError, formatError } from './errors.js';

package/src/io-browser.js ADDED Viewed

@@ -0,0 +1,31 @@
+// io-browser.js — the browser backend for the layered I/O interface (__IO).
+//
+// The frontend half of a full-stack Devabhāṣā app runs in the browser and uses
+// जाल (network) to talk to its backend. The codegen lowers जाल.आनय /
+// आनयप्रदत्त to __IO.net.fetch / fetchJson, so a browser page that runs a
+// compiled frontend needs an __IO whose `net` uses the browser's native fetch.
+//
+// File ops have no meaning in a browser, so सञ्चिका.* returns a clear failure
+// Result rather than throwing — keeping the same program runnable on either
+// host, with the Result telling it what isn't available here.
+//
+// Exported as a source string (like IO_NODE_SOURCE) so the server can prepend
+// it to the frontend bundle it serves.
+export const IO_BROWSER_SOURCE = `// --- देवभाषा I/O (browser backend) ---
+const __IO = (() => {
+  const ok = (v) => ({ "सफल": true, "मूल्यम्": v, "दोषः": null });
+  const err = (e) => ({ "सफल": false, "मूल्यम्": null, "दोषः": String(e && e.message || e) });
+  const noFile = async () => err('file I/O is not available in the browser');
+  return {
+    file: {
+      read: noFile, write: noFile, exists: async () => ok(false),
+      remove: noFile, list: noFile, readJson: noFile, writeJson: noFile,
+    },
+    net: {
+      async fetch(url, options){ try { const res = await fetch(url, options||undefined); const text = await res.text(); return ok({ "स्थितिः": res.status, "पाठः": text, "सफलम्": res.ok }); } catch(e){ return err(e); } },
+      async fetchJson(url, options){ try { const res = await fetch(url, options||undefined); const text = await res.text(); try { return ok({ "स्थितिः": res.status, "प्रदत्तम्": JSON.parse(text), "सफलम्": res.ok }); } catch(e){ return err('JSON: '+(e&&e.message||e)); } } catch(e){ return err(e); } },
+    },
+  };
+})();
+`;

package/src/io-node.js ADDED Viewed

@@ -0,0 +1,102 @@
+// io-node.js — the Node backend for the __IO interface.
+//
+// Layered design: a Devabhāṣā program calls सञ्चिका.पठ / जाल.आनय, which the
+// codegen lowers to __IO.file.read / __IO.net.fetch. The program is bound to
+// the __IO *interface*, never to Node — this file is one concrete backend.
+// A browser backend or an in-memory test backend can implement the same
+// shape and be injected instead.
+//
+// THE __IO CONTRACT (every operation is async and returns a परिणाम/Result):
+//   __IO.file.read(path)            → Promise<Result<string>>
+//   __IO.file.write(path, data)     → Promise<Result<true>>
+//   __IO.file.exists(path)          → Promise<Result<boolean>>
+//   __IO.file.remove(path)          → Promise<Result<true>>
+//   __IO.file.list(dir)             → Promise<Result<string[]>>
+//   __IO.net.fetch(url, options?)   → Promise<Result<{ status, text, ok }>>
+//
+// A Result is { सफल: boolean, मूल्यम्: value, दोषः: error } — the same shape
+// the __RT prelude produces, so awaited results inspect with फल.सफल etc.
+import { readFile, writeFile, unlink, readdir, access } from 'fs/promises';
+const ok = (v) => ({ 'सफल': true, 'मूल्यम्': v, 'दोषः': null });
+const err = (e) => ({ 'सफल': false, 'मूल्यम्': null, 'दोषः': String(e && e.message || e) });
+export const __IO = {
+  file: {
+    async read(path) {
+      try { return ok(await readFile(path, 'utf8')); }
+      catch (e) { return err(e); }
+    },
+    async write(path, data) {
+      try { await writeFile(path, String(data), 'utf8'); return ok(true); }
+      catch (e) { return err(e); }
+    },
+    async exists(path) {
+      try { await access(path); return ok(true); }
+      catch { return ok(false); }   // absence is not an error — it's `false`
+    },
+    async remove(path) {
+      try { await unlink(path); return ok(true); }
+      catch (e) { return err(e); }
+    },
+    async list(dir) {
+      try { return ok(await readdir(dir)); }
+      catch (e) { return err(e); }
+    },
+    async readJson(path) {            // read + parse JSON → परिणाम
+      try {
+        const text = await readFile(path, 'utf8');
+        try { return ok(JSON.parse(text)); }
+        catch (e) { return err('JSON: ' + (e && e.message || e)); }
+      } catch (e) { return err(e); }
+    },
+    async writeJson(path, value) {    // serialize + write
+      try { await writeFile(path, JSON.stringify(value, null, 2), 'utf8'); return ok(true); }
+      catch (e) { return err(e); }
+    },
+  },
+  net: {
+    async fetch(url, options) {
+      try {
+        const res = await fetch(url, options || undefined);
+        const text = await res.text();
+        return ok({ 'स्थितिः': res.status, 'पाठः': text, 'सफलम्': res.ok });
+      } catch (e) { return err(e); }
+    },
+    async fetchJson(url, options) {   // fetch + parse JSON → परिणाम
+      try {
+        const res = await fetch(url, options || undefined);
+        const text = await res.text();
+        try { return ok({ 'स्थितिः': res.status, 'प्रदत्तम्': JSON.parse(text), 'सफलम्': res.ok }); }
+        catch (e) { return err('JSON: ' + (e && e.message || e)); }
+      } catch (e) { return err(e); }
+    },
+  },
+};
+// A source string that defines the same __IO for embedding in `build` output.
+// (For build, we inline the backend so the produced .js is self-contained
+// when run under Node.)
+export const IO_NODE_SOURCE = `// --- देवभाषा I/O (Node backend) ---
+const __IO = (() => {
+  const { readFile, writeFile, unlink, readdir, access } = require('fs/promises');
+  const ok = (v) => ({ "सफल": true, "मूल्यम्": v, "दोषः": null });
+  const err = (e) => ({ "सफल": false, "मूल्यम्": null, "दोषः": String(e && e.message || e) });
+  return {
+    file: {
+      async read(p){ try { return ok(await readFile(p,'utf8')); } catch(e){ return err(e); } },
+      async write(p,d){ try { await writeFile(p,String(d),'utf8'); return ok(true); } catch(e){ return err(e); } },
+      async exists(p){ try { await access(p); return ok(true); } catch { return ok(false); } },
+      async remove(p){ try { await unlink(p); return ok(true); } catch(e){ return err(e); } },
+      async list(dir){ try { return ok(await readdir(dir)); } catch(e){ return err(e); } },
+      async readJson(p){ try { const t = await readFile(p,'utf8'); try { return ok(JSON.parse(t)); } catch(e){ return err('JSON: '+(e&&e.message||e)); } } catch(e){ return err(e); } },
+      async writeJson(p,v){ try { await writeFile(p,JSON.stringify(v,null,2),'utf8'); return ok(true); } catch(e){ return err(e); } },
+    },
+    net: {
+      async fetch(url, options){ try { const res = await fetch(url, options||undefined); const text = await res.text(); return ok({ "स्थितिः": res.status, "पाठः": text, "सफलम्": res.ok }); } catch(e){ return err(e); } },
+      async fetchJson(url, options){ try { const res = await fetch(url, options||undefined); const text = await res.text(); try { return ok({ "स्थितिः": res.status, "प्रदत्तम्": JSON.parse(text), "सफलम्": res.ok }); } catch(e){ return err('JSON: '+(e&&e.message||e)); } } catch(e){ return err(e); } },
+    },
+  };
+})();
+`;

package/src/karaka-web.js ADDED Viewed

@@ -0,0 +1,49 @@
+// karaka-web.js — maps kāraka roles to web/DOM construction semantics,
+// and defines which stems name which DOM concepts.
+//
+// The signature verb रचय (racaya, "construct") takes a BAG of case-marked
+// arguments in ANY ORDER and assembles a DOM element. Each kāraka fills a
+// distinct slot, so order is irrelevant — exactly the Pāṇinian promise.
+import { KARAKA } from './vibhakti.js';
+// kāraka → which slot of a DOM construction it fills.
+export const KARAKA_TO_SLOT = {
+  [KARAKA.KARTR]:      'tag',     // कर्तृ  (nom)  — what the element IS (div, button…)
+  [KARAKA.KARMAN]:     'content', // कर्म   (acc)  — content placed into it
+  [KARAKA.KARANA]:     'handler', // करण   (instr)— the handler function (instrument)
+  [KARAKA.SAMPRADANA]: 'event',   // सम्प्रदान (dat) — event it responds to
+  [KARAKA.ADHIKARANA]: 'parent',  // अधिकरण (loc) — where it mounts (locus)
+  [KARAKA.APADANA]:    'source',  // अपादान (abl) — data source it derives from
+  [KARAKA.SAMBANDHA]:  'prop',    // सम्बन्ध (gen) — attribute/property relation
+};
+// Stem vocabulary: nominative-case stems that name HTML tags.
+// The user writes these inflected (पटः, मूलकम्…); the engine reads the
+// ending for the role and this table for the tag name.
+export const TAG_STEMS = {
+  'पट':    'button',   // paṭa — "cloth/panel" → button
+  'मूल':   'div',      // mūla — "root/base"   → div (generic container)
+  'शीर्ष': 'h1',       // śīrṣa — "head"       → heading
+  'वाक्य': 'p',        // vākya — "sentence"   → paragraph
+  'सूची':  'ul',       // sūcī — "list"        → list
+  'पङ्क्ति':'li',      // paṅkti — "row/line"  → list item
+  'पीठ':   'input',    // pīṭha — "seat/field" → input
+  'चित्र': 'img',      // citra — "picture"    → image
+  'सेतु':  'a',        // setu — "bridge/link" → anchor
+  'क्षेत्र':'span',     // kṣetra — "field/area"→ span
+};
+// Event stems (used in सम्प्रदान / dative position).
+export const EVENT_STEMS = {
+  'स्पर्श': 'click',     // sparśa — "touch"   → click
+  'परिवर्तन':'change',   // parivartana        → change
+  'निवेश': 'input',      // niveśa — "entry"   → input
+  'प्रेषण': 'submit',    // preṣaṇa — "sending"→ submit
+};
+// Construction / action verbs.
+export const KARAKA_VERBS = {
+  'रचय':  'CONSTRUCT',  // racaya — "construct" → build DOM element from kārakas
+  'योजय': 'ATTACH',     // yojaya — "join"      → mount (also legacy keyword)
+};

package/src/keywords.js ADDED Viewed

@@ -0,0 +1,64 @@
+// keywords.js — the Sanskrit-language surface layer.
+// Edit vocabulary here without touching the lexer/parser/codegen.
+//
+// Each keyword maps a Devanagari word -> an internal token type.
+// The internal token types are language-neutral so the rest of the
+// compiler never sees Sanskrit directly.
+export const KEYWORDS = {
+  // declarations
+  'चर':      'LET',        // cara — "it varies" → mutable binding
+  'नियत':    'CONST',      // niyata — "fixed" → constant
+  'कार्य':    'FUNC',       // kārya — "work to be done" → function
+  'फलम्':     'RETURN',     // phalam — "fruit/result" → return
+  // control flow
+  'यदि':      'IF',         // yadi — if
+  'अन्यथा':   'ELSE',       // anyathā — otherwise
+  'यावत्':    'WHILE',      // yāvat — "as long as" → while
+  'प्रत्येकम्': 'FOR',        // pratyekam — "for each" → for-of
+  'भङ्ग':     'BREAK',      // bhaṅga — "breaking" → break
+  'अनुवृत्तम्': 'CONTINUE',   // anuvṛttam — "continuing" → continue
+  // literals
+  'सत्यम्':    'TRUE',       // satyam — true
+  'असत्यम्':   'FALSE',      // asatyam — false
+  'शून्यम्':   'NULL',       // śūnyam — "void/zero" → null
+  // web / DOM layer
+  'दर्शय':     'PRINT',      // darśaya — "cause to show" → console.log
+  'अङ्गम्':    'ELEMENT',    // aṅgam — "limb/part" → createElement
+  'योजय':     'MOUNT',      // yojaya — "join/attach" → append to DOM
+  'श्रोता':    'LISTEN',     // śrotā — "listener" → addEventListener
+  'रचय':      'CONSTRUCT',  // racaya — "construct" → kāraka-based DOM builder
+  'कोष':      'OBJECT',     // kośa — "treasury/dictionary" → object literal
+  'रूप':      'STYLE',      // rūpa — "form/appearance" → style block
+  'रूपनाम':   'STYLENAME',  // rūpanāma — "form-name" → named reusable style
+  'भाव':      'STATE',      // bhāva — "state/condition" → reactive state cell
+  'दृश्य':     'VIEW',       // dṛśya — "view/visible" → reactive view region
+  'निर्यात':   'EXPORT',     // niryāta — "sending out" → export
+  'आयात':     'IMPORT',     // āyāta — "incoming" → import
+  'आ':        'FROM',       // ā — "from" → module source preposition
+  'असमकालिक': 'ASYNC',      // asamakālika — "asynchronous" → async function
+  'प्रतीक्षा':  'AWAIT',      // pratīkṣā — "waiting" → await
+  'अथवा':      'ORELSE',     // athavā — "or else" → Result value-or-fallback
+  'सूत्र':      'SUTRA',      // sūtra — "thread" → a reactive reference (lazy, live)
+};
+// Reverse map for error messages / pretty-printing.
+export const TOKEN_TO_WORD = Object.fromEntries(
+  Object.entries(KEYWORDS).map(([word, tok]) => [tok, word])
+);
+// Multi-character operators must be listed longest-first so the lexer
+// matches '==' before '=', '+=' before '+', etc.
+export const OPERATORS = [
+  '===', '!==', '??',
+  '==', '!=', '<=', '>=', '&&', '||',
+  '+=', '-=', '*=', '/=', '%=', '++', '--',
+  '+', '-', '*', '/', '%', '=', '<', '>', '!', '?',
+  '(', ')', '{', '}', '[', ']', ',', ';', '.', ':',
+];
+// Devanagari danda (।) is accepted as a statement terminator, like ';'.
+export const DANDA = '।';

package/src/lexer.js ADDED Viewed

@@ -0,0 +1,140 @@
+// lexer.js — turns Devanagari source text into a flat token stream.
+import { KEYWORDS, OPERATORS, DANDA } from './keywords.js';
+import { DevabhashaError } from './errors.js';
+// Devanagari block: U+0900–U+097F. We treat a "word" as a run of
+// Devanagari letters, virama, matras, anusvara, etc. plus ASCII letters.
+// We exclude Devanagari punctuation: danda । (U+0964) and double danda ॥
+// (U+0965), which are statement terminators, not identifier characters.
+const DEVA = /[\u0900-\u0963\u0966-\u097F]/;
+const DEVA_DIGITS = '०१२३४५६७८९';
+function isWordChar(ch) {
+  return DEVA.test(ch) || /[A-Za-z_]/.test(ch);
+}
+function isDigit(ch) {
+  return /[0-9]/.test(ch) || DEVA_DIGITS.includes(ch);
+}
+function normalizeDigit(ch) {
+  const i = DEVA_DIGITS.indexOf(ch);
+  return i >= 0 ? String(i) : ch;
+}
+export function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  const push = (type, value) => tokens.push({ type, value, line, col });
+  const advance = (n = 1) => { i += n; col += n; };
+  while (i < src.length) {
+    const ch = src[i];
+    // whitespace
+    if (ch === '\n') { line++; col = 1; i++; continue; }
+    if (/\s/.test(ch)) { advance(); continue; }
+    // comments:  # to end of line
+    if (ch === '#') {
+      while (i < src.length && src[i] !== '\n') i++;
+      continue;
+    }
+    // danda → statement terminator
+    if (ch === DANDA) { push('SEMI', ';'); advance(); continue; }
+    // strings: "..." with \ escapes (plain — no interpolation by default).
+    // Interpolation is opt-in via the पाठ"…{expr}…" marker (handled below in
+    // the word branch), so existing strings containing literal braces are safe.
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      const startLine = line, startCol = col;
+      advance();
+      let str = '';
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === '\\') { str += src[i] + src[i + 1]; advance(2); }
+        else if (src[i] === '\n') { line++; col = 1; str += '\n'; i++; }
+        else { str += src[i]; advance(); }
+      }
+      advance(); // closing quote
+      tokens.push({ type: 'STRING', value: str, line: startLine, col: startCol });
+      continue;
+    }
+    // numbers (supports Devanagari digits and decimals)
+    if (isDigit(ch)) {
+      let num = '';
+      while (i < src.length && (isDigit(src[i]) || src[i] === '.')) {
+        num += normalizeDigit(src[i]);
+        advance();
+      }
+      push('NUMBER', num);
+      continue;
+    }
+    // words → keyword or identifier
+    if (isWordChar(ch)) {
+      const wStartLine = line, wStartCol = col;
+      let word = '';
+      while (i < src.length && (isWordChar(src[i]) || isDigit(src[i]))) {
+        word += src[i];
+        advance();
+      }
+      // पाठ"…{expr}…" — an interpolated string. Only when पाठ is immediately
+      // followed by a quote (no space), so the plain identifier पाठ is unaffected.
+      if (word === 'पाठ' && (src[i] === '"' || src[i] === "'")) {
+        const quote = src[i];
+        advance(); // opening quote
+        const chunks = [''];
+        const exprs = [];
+        while (i < src.length && src[i] !== quote) {
+          if (src[i] === '\\') {
+            const nxt = src[i + 1];
+            if (nxt === '{' || nxt === '}') { chunks[chunks.length - 1] += nxt; advance(2); }
+            else { chunks[chunks.length - 1] += src[i] + nxt; advance(2); }
+          } else if (src[i] === '{') {
+            advance(); // {
+            let depth = 1, expr = '';
+            while (i < src.length && depth > 0) {
+              if (src[i] === '{') depth++;
+              else if (src[i] === '}') { depth--; if (depth === 0) break; }
+              if (src[i] === '\n') { line++; col = 1; expr += '\n'; i++; }
+              else { expr += src[i]; advance(); }
+            }
+            advance(); // }
+            exprs.push(expr);
+            chunks.push('');
+          } else if (src[i] === '\n') { line++; col = 1; chunks[chunks.length - 1] += '\n'; i++; }
+          else { chunks[chunks.length - 1] += src[i]; advance(); }
+        }
+        advance(); // closing quote
+        tokens.push({ type: 'TEMPLATE', chunks, exprs, line: wStartLine, col: wStartCol });
+        continue;
+      }
+      if (KEYWORDS[word]) push(KEYWORDS[word], word);
+      else push('IDENT', word);
+      continue;
+    }
+    // operators / punctuation
+    const three = src.slice(i, i + 3);
+    const two = src.slice(i, i + 2);
+    if (OPERATORS.includes(three)) { push('OP', three); advance(3); continue; }
+    if (OPERATORS.includes(two)) {
+      const t = two === ';' ? 'SEMI' : 'OP';
+      push(t, two); advance(2); continue;
+    }
+    if (OPERATORS.includes(ch)) {
+      const t = ch === ';' ? 'SEMI' : 'OP';
+      push(t, ch); advance(); continue;
+    }
+    throw new DevabhashaError(`अज्ञातं चिह्नम् (unknown character) '${ch}'`, { line, col, kind: 'lex' });
+  }
+  push('EOF', null);
+  return tokens;
+}