sampler mask from blacklist added.

app.py

@@ -26,6 +26,7 @@ import gradio as gr
 
 from lilyscript.generator import StreamingLilyletGenerator
 from lilyscript.postprocess import postprocess
+from lilyscript.mask_monitor import MaskMonitor, load_blacklist
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 # Model weights are pulled from the HuggingFace model repo `k-l-lambda/LilyNota`
@@ -53,6 +54,13 @@ INSTRUMENTS = _STYLES['instruments']
 
 _GEN = None
 
+# Syntax-blacklist mask: discovered 2-grams whose forbidden next-tokens are masked
+# during sampling so the model can't emit those locally-illegal continuations.
+# Loaded once at startup; a fresh (stateful) MaskMonitor is built per generation.
+# Empty/missing file -> no masking (behavior unchanged).
+BLACKLIST_PATH = os.path.join(ASSET_DIR, 'lilylet-blacklist.json')
+_BLACKLIST = load_blacklist(BLACKLIST_PATH)
+
 
 # ---- system log capture ----------------------------------------------------
 # A ring buffer that mirrors Python logging (lifecycle messages, warnings, and
@@ -124,6 +132,8 @@ def get_generator ():
 		t0 = time.perf_counter()
 		_GEN = StreamingLilyletGenerator(model_dir, ASSET_DIR)
 		LOG.info('generator ready (%.1fs)', time.perf_counter() - t0)
+		LOG.info('syntax blacklist: %d contexts / %d forbidden pairs from %s',
+			len(_BLACKLIST), sum(len(v) for v in _BLACKLIST.values()), BLACKLIST_PATH)
 	return _GEN
 
 
@@ -231,12 +241,15 @@ def run_generation (prompt, measures, temperature, max_patches, seed, store, top
 	t0 = time.perf_counter()
 	try:
 		gen = get_generator()
+		# build a fresh per-run mask monitor (stateful: tracks the running 2-gram).
+		# None when no blacklist is loaded -> sampling path unchanged.
+		monitor = MaskMonitor(gen, _BLACKLIST) if _BLACKLIST else None
 		# drop a marker in the log timeline; _log_panel expands it to the live output,
 		# so subsequent log lines (timing/done) land *after* the generation text.
 		LOG.info(_GEN_MARKER)
 		for raw, pretty, done in gen.generate_stream(
 			prompt_text=prompt or '', max_patches=mp, temperature=float(temperature),
-			top_k=int(top_k), top_p=float(top_p), measures=meas, seed=int(seed)):
+			top_k=int(top_k), top_p=float(top_p), measures=meas, seed=int(seed), monitor=monitor):
 			if not done:
 				n_yields += 1
 			# progress on the Generate button label: by measures (completed `|`

assets/lilylet-blacklist.json

@@ -0,0 +1,37 @@
+{
+  "meta": {
+    "temperature": 1.5,
+    "top_p": 0.995,
+    "top_k": 0,
+    "seed": 0,
+    "restarts": 50,
+    "measures": -1,
+    "tokens": 43039,
+    "oracle_calls": 20294,
+    "elapsed_s": 403.4,
+    "model_dir": "/home/camus/data/models/LilyNota/onnx"
+  },
+  "blacklist": {
+    "93": [
+      44,
+      46,
+      126
+    ],
+    "167": [
+      167,
+      168
+    ],
+    "226": [
+      44,
+      45,
+      46,
+      52
+    ],
+    "244": [
+      44
+    ],
+    "248,202,34,124": [
+      46
+    ]
+  }
+}

lilyscript/generator.py

@@ -22,9 +22,25 @@ import onnxruntime as ort
 from .postprocess import postprocess
 
 
-def sample_next (logits, rng, temperature=1.0, top_k=0, top_p=1.0):
-	'''Sample one token id from a logits vector (numpy) with temperature/top-k/top-p.'''
+class _StreamAborted (Exception):
+	'''Raised by the token loop when a syntax monitor exhausts its redraw budget,
+	signalling generate_stream to end the stream cleanly rather than commit a bad
+	token (which would corrupt the monitor's running text). Internal to the
+	blacklist-discovery path; never raised when monitor is None.'''
+	pass
+
+
+def sample_next (logits, rng, temperature=1.0, top_k=0, top_p=1.0, banned_ids=None):
+	'''Sample one token id from a logits vector (numpy) with temperature/top-k/top-p.
+
+	banned_ids: optional iterable of token ids to forbid; their logits are set to
+	-inf before any other filtering, so they can never be drawn (used by the
+	syntax-blacklist mask in tools/lilylet_blacklist_gen.py). Default None = no-op.
+	'''
 	logits = logits.astype(np.float64)
+	if banned_ids:
+		logits = logits.copy()
+		logits[list(banned_ids)] = -np.inf
 	if temperature != 1.0:
 		logits = logits / max(temperature, 1e-6)
 	if top_k and top_k > 0:
@@ -136,11 +152,24 @@ class StreamingLilyletGenerator:
 			new_past.append(out[f'new_v_{i}'])
 		return out['logits'][0, -1], new_past
 
-	def _generate_patch (self, last_hidden, rng, prefix_ids=None, temperature=1.0, top_k=0, top_p=1.0):
+	def _generate_patch (self, last_hidden, rng, prefix_ids=None, temperature=1.0, top_k=0, top_p=1.0,
+		monitor=None, max_redraws=16):
 		'''Token-level decode for one patch through the token-KV session: feed the
-		patch state, then bos+prefix embeddings, then sample until the patch is full.'''
+		patch state, then bos+prefix embeddings, then sample until the patch is full.
+
+		monitor: optional syntax-blacklist hook (default None -> unchanged behavior).
+		  - monitor.banned() -> iterable of token ids to mask for the next draw,
+		  - monitor.accept(id) -> bool: True to commit the drawn token, False to
+		    redraw (the monitor records the violation + grows its ban set internally),
+		  - monitor.commit_forced(id): notified of each forced (non-sampled) token so
+		    its running context/stream stay correct.
+		Forced tokens (bos + prefix_ids) bypass accept()/redraw — only commit_forced.
+		'''
 		generated = list(prefix_ids or [])
 		tokens = [self.bos_id] + list(prefix_ids or [])
+		if monitor is not None:
+			for tid in prefix_ids or []:
+				monitor.commit_forced(tid)
 		past = self._empty_token_past()
 		enc = last_hidden.reshape(1, 1, -1).astype(np.float32)
 		logits, past = self._token_kv_step(enc, past)
@@ -148,7 +177,24 @@ class StreamingLilyletGenerator:
 			emb = self.wte[tokens[i]].reshape(1, 1, -1)
 			logits, past = self._token_kv_step(emb, past)
 		while len(generated) < self.patch_size:
-			nxt = sample_next(logits, rng, temperature=temperature, top_k=top_k, top_p=top_p)
+			if monitor is None:
+				nxt = sample_next(logits, rng, temperature=temperature, top_k=top_k, top_p=top_p)
+			else:
+				# draw with the current ban mask; on a rejected (illegal) token the
+				# monitor records it and we redraw from the SAME logits with the now-
+				# larger mask. The token KV cache is only advanced for the committed
+				# token below, so redrawing here costs nothing.
+				for _ in range(max_redraws):
+					nxt = sample_next(logits, rng, temperature=temperature, top_k=top_k, top_p=top_p,
+						banned_ids=monitor.banned())
+					if monitor.accept(nxt):
+						break
+				else:
+					# every redraw was rejected. Committing a bad token would corrupt
+					# the monitor's running text (every subsequent token would then
+					# parse-fail and be mis-recorded), so abort the stream cleanly
+					# instead — the caller (generate_stream) ends generation here.
+					raise _StreamAborted()
 			generated.append(nxt)
 			if len(generated) < self.patch_size:
 				emb = self.wte[nxt].reshape(1, 1, -1)
@@ -156,13 +202,19 @@ class StreamingLilyletGenerator:
 		return generated
 
 	def generate_stream (self, prompt_text='', max_patches=256, temperature=1.0, top_k=0,
-		top_p=0.9, measures=None, seed=0):
+		top_p=0.9, measures=None, seed=0, monitor=None):
 		'''Autoregressive generation, yielding after every patch.
 
 		Yields (raw, pretty, done):
 		  raw    -- accumulated decoded patch text (with `[r:x/y]` markers), for the log
 		  pretty -- postprocess(raw), measure-segmented, for the editor
 		  done   -- True on the final yield (EOS patch or max_patches reached)
+
+		monitor: optional syntax-blacklist hook threaded into the token decode loop
+		  (default None -> behavior identical to before). When a monitor is given the
+		  `[r:0/<measures>]` priming re-sample is disabled: priming is a probe-then-
+		  discard draw that would corrupt the monitor's running stream, and the
+		  blacklist harness wants free generation anyway.
 		'''
 		rng = np.random.default_rng(seed)
 
@@ -179,6 +231,12 @@ class StreamingLilyletGenerator:
 		prime_ids = self.tokenizer.encode(f'[r:0/{measures}]') if measures is not None else None
 		primed = False
 
+		# seed the monitor's running context/stream from the prompt patches (if any)
+		if monitor is not None and len(patches) > 1:
+			for p in patches[1:]:
+				for tid in p:
+					monitor.commit_forced(tid)
+
 		# prefill: run all seed patches through the patch-KV decoder in one call
 		past = self._empty_patch_past()
 		last, past = self._patch_kv_step(patches, past)
@@ -186,14 +244,29 @@ class StreamingLilyletGenerator:
 		yield out_text, postprocess(out_text), False
 
 		for _ in range(max_patches):
-			patch_ids = self._generate_patch(last, rng, temperature=temperature, top_k=top_k, top_p=top_p)
+			# If a monitor supports priming-rewind (mark/rollback), snapshot before the
+			# draw so a discarded probe patch can be undone (see priming below).
+			can_prime_with_monitor = monitor is not None and hasattr(monitor, 'mark')
+			if can_prime_with_monitor:
+				monitor.mark()
+			try:
+				patch_ids = self._generate_patch(last, rng, temperature=temperature, top_k=top_k, top_p=top_p,
+					monitor=monitor)
+			except _StreamAborted:
+				break
 
 			# first time the model emits a stream patch, re-sample with the forced
 			# `[r:0/<measures>]` prefix so the body starts at the requested measure count.
-			if prime_ids is not None and not primed and self.patch_to_text(patch_ids).startswith('[r:'):
+			# With a priming-capable monitor we rewind its running text first, so the
+			# discarded probe patch doesn't pollute the 2-gram context. (The discovery
+			# harness's monitor lacks mark/rollback, so priming stays disabled there.)
+			if prime_ids is not None and not primed and self.patch_to_text(patch_ids).startswith('[r:') \
+					and (monitor is None or can_prime_with_monitor):
 				primed = True
+				if can_prime_with_monitor:
+					monitor.rollback()
 				patch_ids = self._generate_patch(last, rng, prefix_ids=prime_ids,
-					temperature=temperature, top_k=top_k, top_p=top_p)
+					temperature=temperature, top_k=top_k, top_p=top_p, monitor=monitor)
 
 			# EOS patch -> done
 			if patch_ids[0] == self.bos_id and patch_ids[1] == self.eos_id:

lilyscript/mask_monitor.py

@@ -0,0 +1,128 @@
+"""Runtime syntax-blacklist mask for live generation.
+
+A lightweight, parse-free counterpart to tools/lilylet_blacklist_gen.py's
+BlacklistMonitor. It does NOT call any parser/oracle and has no Node dependency:
+it simply trusts a pre-discovered 2-gram blacklist and masks the forbidden next
+tokens during sampling. Suitable for the Gradio app's live generation path.
+
+Wire-compatible with StreamingLilyletGenerator's `monitor` hook:
+  banned()          -> ids to mask for the next draw (blacklist[current 2-gram])
+  accept(id)->bool  -> always True (we trust the mask; never re-parse)
+  commit_forced(id) -> advance running text/context for a forced token
+Plus mark()/rollback() so the generator's `[r:0/<measures>]` priming re-sample
+(a probe-then-discard draw) can rewind the running text before the forced redraw.
+
+The 2-gram context is the last two CONTENT token ids of the marker-stripped
+stream (markers aren't real Lilylet), recomputed from a bounded text suffix so it
+"sees through" `[r:x/y]` markers exactly as the discovery monitor did.
+"""
+
+import os
+import re
+import json
+
+# A complete stream marker `[r:<digits>/<digits>]`; a trailing partial `[r…`.
+# (Mirror tools/lilylet_blacklist_gen.py: only strip a confirmed `[r` prefix, never
+# a bare `[`, which is real content — a header `[composer …]` or beam `c8[`.)
+_MARKER_COMPLETE = re.compile(r'\[r:\d+/\d*\]')
+_MARKER_PARTIAL_TAIL = re.compile(r'\[r(:(\d+(/\d*)?)?)?$')
+
+
+def _clean (raw):
+	return _MARKER_PARTIAL_TAIL.sub('', _MARKER_COMPLETE.sub('', raw))
+
+
+def _whitespace_ids (tokenizer):
+	'''Token ids for space/newline/tab/CR present in the vocab — dropped from the
+	content context so it matches the corpus index space the blacklist was keyed in.'''
+	out = []
+	for ch in (' ', '\n', '\t', '\r'):
+		enc = tokenizer.encode(ch)
+		if len(enc) == 1:
+			out.append(enc[0])
+	return out
+
+
+def load_blacklist (path):
+	'''Load a blacklist JSON ({"id1,...,idn": [ids...]} under a top-level "blacklist"
+	key, or bare) into dict[tuple(int,...) -> set[int]]. Keys are variable-length
+	context n-grams. Missing file -> {}.'''
+	if not path or not os.path.isfile(path):
+		return {}
+	data = json.load(open(path))
+	raw = data.get('blacklist', data) if isinstance(data, dict) else {}
+	bl = {}
+	for key, ids in raw.items():
+		ctx = tuple(int(x) for x in key.split(',')) if key else ()
+		bl[ctx] = set(int(i) for i in ids)
+	return bl
+
+
+class MaskMonitor:
+	'''Parse-free runtime mask. Construct with the generator (for tokenizer +
+	special ids) and a variable-length-keyed blacklist dict; pass as `monitor=` to
+	generate_stream. A key (a,b,c) masks its forbidden tokens whenever the running
+	content context ends with the sequence a,b,c (longest/any suffix match).'''
+
+	def __init__ (self, gen, blacklist):
+		self.tk = gen.tokenizer
+		self.blacklist = blacklist or {}
+		self.pad_id, self.bos_id, self.eos_id = gen.pad_id, gen.bos_id, gen.eos_id
+		self._ws = set(_whitespace_ids(self.tk))
+		self._key_lengths = sorted({len(k) for k in self.blacklist}, reverse=True) if self.blacklist else []
+		self._max_ctx = max(self._key_lengths) if self._key_lengths else 0
+		self.raw = ''
+		self._ctx_ids = []           # last <=_max_ctx content non-whitespace ids
+		self._mark = None
+
+	def _is_content (self, tid):
+		return tid not in (self.pad_id, self.bos_id, self.eos_id)
+
+	def _is_ctx (self, tid):
+		return self._is_content(tid) and int(tid) not in self._ws
+
+	def _text (self, tid):
+		tid = int(tid)
+		return '' if not self._is_content(tid) else self.tk.text_by_id.get(tid, '')
+
+	def _sync_ctx (self):
+		clean = _clean(self.raw)
+		ids = self.tk.encode(clean[-256:])
+		ctx = [i for i in ids if self._is_ctx(i)]
+		self._ctx_ids = ctx[-self._max_ctx:] if self._max_ctx else []
+
+	# ---- generator-facing API ----
+
+	def banned (self):
+		'''Union forbidden sets of every stored key that is a suffix of the context.'''
+		if not self._key_lengths:
+			return ()
+		ctx = self._ctx_ids
+		out = set()
+		for n in self._key_lengths:
+			if n <= len(ctx):
+				hit = self.blacklist.get(tuple(ctx[-n:]))
+				if hit:
+					out |= hit
+		return out
+
+	def accept (self, tid):
+		# trust the mask: a non-banned draw is always committed (no re-parse)
+		self.commit_forced(tid)
+		return True
+
+	def commit_forced (self, tid):
+		self.raw += self._text(tid)
+		self._sync_ctx()
+
+	# ---- priming support (probe-then-discard rewind) ----
+
+	def mark (self):
+		'''Remember the current running text so a discarded probe patch can be undone.'''
+		self._mark = self.raw
+
+	def rollback (self):
+		'''Rewind to the last mark() (drops a probe patch's effect on the context).'''
+		if self._mark is not None:
+			self.raw = self._mark
+			self._sync_ctx()