Export
@@ -1609,6 +1624,64 @@
const openOv=id=>{$(id).hidden=false;};
const closeOv=id=>{$(id).hidden=true;};
$('imgBtn').onclick=()=>openOv('ovImg');
+
+/* The program panel. Everything here runs against the same dslRender the
+ verification suite holds byte-for-byte against the Python oracle, so what is
+ rendered in the panel is what the fixtures cover. */
+const DSL_PRESETS={
+ Stripes:{canvas:{width:32,height:32,scale:1,autoSize:true},
+ layers:[{op:'set',shape:{type:'stripes',axis:'v',period:8,thickness:4}}],post:{}},
+ Diagonal:{canvas:{width:32,height:32,scale:1,autoSize:true},
+ layers:[{op:'set',shape:{type:'diagonal',dx:1,dy:1,period:8,thickness:3}}],post:{}},
+ Checker:{canvas:{width:32,height:32,scale:1,autoSize:true},
+ layers:[{op:'set',shape:{type:'checker',cellW:4,cellH:4}}],post:{}},
+ Plaid:{canvas:{width:32,height:32,scale:1,autoSize:true},
+ layers:[{op:'set',shape:{type:'stripes',axis:'v',period:8,thickness:3}},
+ {op:'xor',shape:{type:'stripes',axis:'h',period:6,thickness:2}}],post:{}},
+ Houndstooth:{canvas:{width:32,height:32,scale:1,autoSize:true},
+ layers:[{op:'set',shape:{type:'checker',cellW:4,cellH:4}},
+ {op:'xor',shape:{type:'diagonal',dx:1,dy:1,period:8,thickness:4}}],post:{}},
+};
+function dslShow(prog){$('dslSrc').value=JSON.stringify(prog,null,1);dslPreviewStat();}
+function dslPreviewStat(){
+ try{
+ const r=dslRender(JSON.parse($('dslSrc').value));
+ const ink=r.bits.reduce((a,b)=>a+b,0);
+ $('dslStat').innerHTML=''+r.w+'×'+r.h+
+ ' · '+Math.round(100*ink/(r.w*r.h))+'% ink · scale '+(1<';
+ }catch(e){
+ $('dslStat').innerHTML=''+e.message+'';}
+}
+(()=>{const el=$('dslPresets');
+ for(const name of Object.keys(DSL_PRESETS)){
+ const b=document.createElement('button');b.className='b';b.textContent=name;
+ b.onclick=()=>dslShow(DSL_PRESETS[name]);el.appendChild(b);}})();
+$('dslBtn').onclick=()=>{
+ if(!$('dslSrc').value.trim()) dslShow(DSL_PRESETS.Diagonal);
+ openOv('ovDsl');dslPreviewStat();};
+$('dslX').onclick=()=>closeOv('ovDsl');
+$('ovDsl').addEventListener('pointerdown',e=>{if(e.target===$('ovDsl'))closeOv('ovDsl');});
+$('dslSrc').oninput=dslPreviewStat;
+$('dslGo').onclick=()=>{
+ let r;
+ try{ r=dslRender(JSON.parse($('dslSrc').value)); }
+ catch(e){ $('dslStat').innerHTML=''+e.message+''; return; }
+ snap();
+ doc.w=r.w;doc.h=r.h;
+ // A program is one bit per pixel, which is the two-colour document exactly:
+ // slot 1 is the primary the format calls bit 0, slot 2 the secondary. Keep an
+ // existing duotone rather than resetting the user's colours.
+ if(doc.palette.length!==3)
+ doc.palette=[{r:0,g:0,b:0,a:0},{r:255,g:255,b:255,a:255},{r:0,g:0,b:0,a:255}];
+ doc.layers=[{name:'Program',visible:true,locked:false,opacity:1}];
+ const idx=new Uint8Array(r.w*r.h);
+ for(let i=0;icloseOv('ovImg');
$('ovImg').addEventListener('pointerdown',e=>{if(e.target===$('ovImg'))closeOv('ovImg');});
$('drop').onclick=()=>$('file').click();
@@ -1819,6 +1892,269 @@
const px=floorMod(wx>>d.scale,d.w),py=floorMod(wy>>d.scale,d.h);
return d.bits[py*d.w+px]===0;
}
+
+/* ═══════ pattern DSL ═══════
+ A pattern described as a program rather than drawn: 15 primitives, each with a
+ declared period, composed with set/union/intersect/xor/subtract and sized so
+ the result tiles seamlessly by construction. Ported from tools/dsl_prototype.py,
+ which tools/dsl_demo.py proves tiles 28/28, and held byte-for-byte against
+ tests/fixtures/dsl.json.
+
+ Four things do NOT survive a literal translation from Python, and every one of
+ them is a silent wrong answer rather than an error:
+
+ * `round()` is banker's rounding — round(2.5) is 2, round(3.5) is 4 —
+ where Math.round always goes up. It decides wave offsets and canvas
+ sizing, so pyRound() below reproduces it.
+ * `%` is a floor modulo in Python and a remainder in JS. Any expression
+ that can go negative (a diagonal's x*dy - y*dx, a wave's y - offset)
+ needs floorMod.
+ * `//` floors; `|0` truncates toward zero. Same thing only for non-negative
+ operands, so Math.floor is used throughout rather than a bit trick.
+ * _hash2 multiplies by constants near 2^31. A plain `*` passes 2^53 and
+ silently drops low bits, so the mixing steps go through Math.imul.
+*/
+const DSL_MIN_W=2,DSL_MAX_W=129,DSL_MIN_H=2,DSL_MAX_H=65,DSL_MAX_LAYERS=4;
+
+/** Python's round(): halves go to the nearest even, not always up. */
+function pyRound(x){
+ const f=Math.floor(x),d=x-f;
+ if(d>0.5) return f+1;
+ if(d<0.5) return f;
+ return f%2===0?f:f+1;
+}
+function gcd(a,b){a=Math.abs(a);b=Math.abs(b);while(b){const t=a%b;a=b;b=t;}return a||1;}
+function lcm(a,b){return Math.abs(a*b)/gcd(a,b);}
+
+/** Deterministic [0,1). Stable across languages, which is why noise fixtures work. */
+function hash2(x,y,seed){
+ let h=(Math.imul(x,374761393)+Math.imul(y,668265263)+Math.imul(seed,2246822519))>>>0;
+ h=Math.imul(h^(h>>>13),1274126177)>>>0;
+ return ((h^(h>>>16))>>>0)/4294967296;
+}
+
+/* Bitmap fonts for the `text` primitive: one integer per row, MSB-leftmost. */
+const F57={0:[14,17,19,21,25,17,14],1:[4,12,4,4,4,4,14],2:[14,17,1,2,4,8,31],3:[31,2,4,2,1,17,14],4:[2,6,10,18,31,2,2],5:[31,16,30,1,1,17,14],6:[6,8,16,30,17,17,14],7:[31,1,2,4,8,8,8],8:[14,17,17,14,17,17,14],9:[14,17,17,15,1,2,12],A:[14,17,17,31,17,17,17],B:[30,17,17,30,17,17,30],C:[14,17,16,16,16,17,14],D:[30,17,17,17,17,17,30],E:[31,16,16,30,16,16,31],F:[31,16,16,30,16,16,16],G:[14,17,16,23,17,17,15],H:[17,17,17,31,17,17,17],I:[14,4,4,4,4,4,14],J:[7,2,2,2,2,18,12],K:[17,18,20,24,20,18,17],L:[16,16,16,16,16,16,31],M:[17,27,21,21,17,17,17],N:[17,25,21,19,17,17,17],O:[14,17,17,17,17,17,14],P:[30,17,17,30,16,16,16],Q:[14,17,17,17,21,18,13],R:[30,17,17,30,20,18,17],S:[15,16,16,14,1,1,30],T:[31,4,4,4,4,4,4],U:[17,17,17,17,17,17,14],V:[17,17,17,17,17,10,4],W:[17,17,17,21,21,27,17],X:[17,17,10,4,10,17,17],Y:[17,17,10,4,4,4,4],Z:[31,1,2,4,8,16,31]};
+const F35={0:[7,5,5,5,7],1:[2,6,2,2,7],2:[6,1,2,4,7],3:[6,1,2,1,6],4:[5,5,7,1,1],5:[7,4,6,1,6],6:[3,4,7,5,7],7:[7,1,2,2,2],8:[7,5,7,5,7],9:[7,5,7,1,6],A:[2,5,7,5,5],B:[6,5,6,5,6],C:[3,4,4,4,3],D:[6,5,5,5,6],E:[7,4,6,4,7],F:[7,4,6,4,4],G:[3,4,5,5,3],H:[5,5,7,5,5],I:[7,2,2,2,7],J:[1,1,1,5,2],K:[5,5,6,5,5],L:[4,4,4,4,7],M:[5,7,7,5,5],N:[5,7,7,7,5],O:[2,5,5,5,2],P:[6,5,6,4,4],Q:[2,5,5,6,3],R:[6,5,6,5,5],S:[3,4,2,1,6],T:[7,2,2,2,2],U:[5,5,5,5,7],V:[5,5,5,5,2],W:[5,5,7,7,5],X:[5,5,2,5,5],Y:[5,5,2,2,2],Z:[7,1,2,4,7]};
+
+/* Each primitive returns {fn,px,py}: fn(x,y)->0|1, genuinely periodic with the
+ declared period. Those periods are what size_canvas uses to guarantee tiling. */
+const DSL_SHAPES={
+ solid:()=>({fn:()=>1,px:1,py:1}),
+ stripes:(p)=>{
+ const period=p.period??8,phase=p.phase??0;
+ const th=Math.min(p.thickness??4,period-1);
+ return p.axis==='h'
+ ?{fn:(x,y)=>floorMod(y+phase,period)floorMod(x+phase,period){
+ const dx=p.dx??1,dy=p.dy??1,period=p.period??8,phase=p.phase??0;
+ const th=Math.min(p.thickness??4,period-1);
+ return {fn:(x,y)=>floorMod(x*dy-y*dx+phase,period){
+ const cw=p.cellW??4,ch=p.cellH??4,phase=p.phase??0;
+ return {fn:(x,y)=>(Math.floor(x/cw)+Math.floor(y/ch)+phase)%2?1:0,
+ px:2*cw,py:2*ch};},
+ grid:(p)=>{
+ const pX=p.periodX??8,pY=p.periodY??8,fX=p.phaseX??0,fY=p.phaseY??0;
+ const lX=Math.min(p.lineX??1,pX-1),lY=Math.min(p.lineY??1,pY-1);
+ return {fn:(x,y)=>(floorMod(x+fX,pX){
+ const pX=p.periodX??8,pY=p.periodY??8,r=p.radius??2,shape=p.shape??'circle';
+ const rowOff=p.rowOffset??0,jit=p.jitter??0,seed=p.seed??0;
+ const py=floorMod(rowOff,pX)!==0?pY*2:pY;
+ return {fn:(x,y)=>{
+ const row=Math.floor(y/pY),ox=floorMod(row*rowOff,pX);
+ let cx=floorMod(x-ox,pX)-pX/2,cy=floorMod(y,pY)-pY/2;
+ if(jit){
+ cx+=(hash2(Math.floor(x/pX),row,seed)-0.5)*2*jit;
+ cy+=(hash2(row,Math.floor(x/pX),seed+1)-0.5)*2*jit;}
+ const d=shape==='square'?Math.max(Math.abs(cx),Math.abs(cy))
+ :shape==='diamond'?Math.abs(cx)+Math.abs(cy)
+ :Math.hypot(cx,cy);
+ return d<=r?1:0;},px:pX,py};},
+ brick:(p)=>{
+ const bw=p.brickW??8,bh=p.brickH??4,mortar=p.mortar??1,off=p.offset??4;
+ return {fn:(x,y)=>{
+ const row=Math.floor(y/bh),xs=floorMod(x+row*off,bw);
+ return (floorMod(y,bh){
+ const axis=p.axis??'h',period=p.period??16,amp=p.amplitude??3,phase=p.phase??0;
+ const th=p.thickness??2,vp=Math.max(2*amp,th+1);
+ const fn=axis==='h'
+ ?(x,y)=>{const o=pyRound(amp*Math.sin(2*Math.PI*floorMod(x+phase,period)/period));
+ return floorMod(y-o,vp){const o=pyRound(amp*Math.sin(2*Math.PI*floorMod(y+phase,period)/period));
+ return floorMod(x-o,vp){
+ const axis=p.axis??'h',period=p.period??8,amp=p.amplitude??3,th=p.thickness??2;
+ const vp=Math.max(2*amp,th+1),half=period/2;
+ const tri=t=>pyRound(amp*(2*Math.abs(floorMod(t,period)/half-1)-1));
+ const fn=axis==='h'?(x,y)=>floorMod(y-tri(x),vp)floorMod(x-tri(y),vp){
+ const size=p.size??8,down=p.orientation==='down';
+ return {fn:(x,y)=>{
+ const u=floorMod(x,2*size);
+ let v=floorMod(y,size);
+ if(down) v=size-1-v;
+ const half=size-1-v;
+ return (u>=half&&u<2*size-half)?1:0;},px:2*size,py:size};},
+ rings:(p)=>{
+ const period=p.period??16,th=p.thickness??2,cx=p.cx??0,cy=p.cy??0;
+ return {fn:(x,y)=>{
+ const u=floorMod(x+cx,period)-period/2,v=floorMod(y+cy,period)-period/2;
+ const d=Math.trunc(Math.hypot(u,v));
+ return floorMod(d,th*2){
+ const period=p.period??8,angle=p.angle??0;
+ const level=Math.max(0,Math.min(1,p.level??0.5));
+ const r=Math.sqrt(level)*period*0.62;
+ return {fn:(x,y)=>{
+ const xs=angle===45
+ ?floorMod(x+floorMod(Math.floor(y/period),2)*Math.floor(period/2),period)
+ :floorMod(x,period);
+ const u=xs-period/2,v=floorMod(y,period)-period/2;
+ return Math.hypot(u,v)<=r?1:0;},px:period,py:period*(angle===45?2:1)};},
+ noise:(p,canvas)=>{
+ const [w,h]=canvas,density=p.density??0.5,seed=p.seed??0;
+ let grid=[];
+ for(let y=0;y
+ out[floorMod(y+dy,h)][floorMod(x+dx,w)]);
+ if(!near) out[y][x]=1;}
+ grid=out;}
+ return {fn:(x,y)=>grid[floorMod(y,h)][floorMod(x,w)],px:w,py:h};},
+ text:(p)=>{
+ const font=p.font??'5x7',table=font==='5x7'?F57:F35;
+ const gwid=font==='5x7'?5:3,gh=font==='5x7'?7:5;
+ const tracking=p.tracking??1,leading=p.leading??2;
+ let chars=String(p.glyphs??'AB').toUpperCase().split('')
+ .filter(c=>Object.prototype.hasOwnProperty.call(table,c)).slice(0,8);
+ if(!chars.length) chars=['A'];
+ const total=chars.length*(gwid+tracking),vspan=gh+leading;
+ return {fn:(x,y)=>{
+ const v=floorMod(y,vspan);
+ if(v>=gh) return 0; // inside the leading gap
+ const u=floorMod(x,total),idx=Math.floor(u/(gwid+tracking)),col=u%(gwid+tracking);
+ if(col>=gwid||idx>=chars.length) return 0;
+ return (table[chars[idx]][v]>>(gwid-1-col))&1?1:0;},px:total,py:vspan};},
+ border:(p,canvas)=>{
+ const [w,h]=canvas,inset=p.inset??0,th=p.thickness??1;
+ return {fn:(x,y)=>{
+ const u=floorMod(x,w),v=floorMod(y,h);
+ const inner=u>=inset&&u=inset&&v=inset+th&&u=inset+th&&v>>0;
+ if(raw.type==='text'){
+ const g=String(out.glyphs??'A').toUpperCase().replace(/[^A-Z0-9]/g,'').slice(0,8);
+ out.glyphs=g||'A';}
+ return out;
+}
+function dslValidate(prog){
+ if(!prog||typeof prog!=='object') throw new Error('program must be an object');
+ const layers=prog.layers||[];
+ if(!layers.length) throw new Error('program has no layers');
+ if(layers.length>DSL_MAX_LAYERS)
+ throw new Error('too many layers ('+layers.length+' > '+DSL_MAX_LAYERS+')');
+ const clean={canvas:{...(prog.canvas||{})},
+ layers:layers.map(l=>({op:l.op||'union',shape:dslValidateShape(l.shape)})),
+ post:{...(prog.post||{})}};
+ clean.layers[0].op='set'; // nothing to compose against yet
+ return clean;
+}
+
+/* The tiling guarantee: size the canvas to a common multiple of every layer's
+ period, so the edges meet. A period wider than the format can hold cannot
+ tile, and the canvas is capped instead — the seam is then real and reported. */
+function dslSize(program){
+ const c=program.canvas||{},wantW=c.width??16,wantH=c.height??16;
+ if(c.autoSize===false)
+ return [Math.max(DSL_MIN_W,Math.min(DSL_MAX_W,wantW)),
+ Math.max(DSL_MIN_H,Math.min(DSL_MAX_H,wantH))];
+ let px=1,py=1;
+ for(const layer of program.layers){
+ const s=layer.shape;
+ if(DSL_CANVAS_LOCKED.has(s.type)) continue;
+ const {px:sx,py:sy}=DSL_SHAPES[s.type](s,[wantW,wantH]);
+ px=lcm(px,Math.max(1,sx));py=lcm(py,Math.max(1,sy));}
+ const fit=(period,want,lo,hi)=>{
+ if(period>hi) return hi;
+ let size=period*Math.max(1,pyRound(want/period));
+ while(size>hi) size-=period;
+ while(size{const out=new Uint8Array(nw*nh);
+ for(let y=0;ybuf[y*w+(w-1-x)]);
+ if(post.mirrorY) buf=remap(w,h,(x,y)=>buf[(h-1-y)*w+x]);
+ for(let r=0;rsrc[(sh-1-x)*sw+y]);
+ const t=w;w=h;h=t;}
+ if(post.invert) for(let i=0;i dict:
+ return {
+ "canvas": canvas or {"width": 32, "height": 32, "scale": 1, "autoSize": True},
+ "layers": layers or [{"op": "set", "shape": shape}],
+ "post": post or {},
+ }
+
+
+# Each primitive away from its defaults. A port that silently drops a parameter
+# renders the default and passes the gallery; it fails here.
+OFF_DEFAULTS = [
+ ("solid_only", {"type": "solid"}),
+ ("stripes_thin", {"type": "stripes", "axis": "h", "period": 7, "thickness": 2, "phase": 3}),
+ ("diagonal_steep", {"type": "diagonal", "dx": 3, "dy": 2, "period": 12, "thickness": 4, "phase": 5}),
+ ("checker_oblong", {"type": "checker", "cellW": 5, "cellH": 2, "phase": 1}),
+ ("grid_thick", {"type": "grid", "periodX": 9, "periodY": 6, "lineX": 3, "lineY": 2,
+ "phaseX": 2, "phaseY": 4}),
+ ("dots_diamond", {"type": "dots", "periodX": 10, "periodY": 6, "radius": 3,
+ "shape": "diamond", "rowOffset": 5}),
+ ("dots_square_jitter", {"type": "dots", "periodX": 8, "periodY": 8, "radius": 2,
+ "shape": "square", "jitter": 2, "seed": 7}),
+ ("brick_offset", {"type": "brick", "brickW": 10, "brickH": 5, "mortar": 2, "offset": 3}),
+ ("wave_vertical", {"type": "wave", "axis": "v", "period": 14, "amplitude": 4, "thickness": 3,
+ "phase": 2}),
+ ("zigzag_vertical", {"type": "zigzag", "axis": "v", "period": 10, "amplitude": 4, "thickness": 3}),
+ ("triangles_down", {"type": "triangles", "size": 6, "orientation": "down"}),
+ ("rings_offset", {"type": "rings", "period": 12, "thickness": 3, "cx": 4, "cy": 2}),
+ ("halftone_45", {"type": "halftone", "period": 10, "level": 0.8, "angle": 45}),
+ ("halftone_light", {"type": "halftone", "period": 6, "level": 0.15}),
+ ("noise_blue", {"type": "noise", "density": 0.35, "seed": 99, "blue": True}),
+ ("noise_plain", {"type": "noise", "density": 0.6, "seed": 12345}),
+ ("text_3x5", {"type": "text", "glyphs": "OF", "font": "3x5", "tracking": 2, "leading": 3}),
+ ("text_5x7", {"type": "text", "glyphs": "PF9", "font": "5x7", "tracking": 1, "leading": 1}),
+ ("border_inset", {"type": "border", "inset": 3, "thickness": 2}),
+]
+
+OPS = ["set", "union", "intersect", "xor", "subtract"]
+POSTS = [
+ ("post_mirrorX", {"mirrorX": True}),
+ ("post_mirrorY", {"mirrorY": True}),
+ ("post_both_mirrors", {"mirrorX": True, "mirrorY": True}),
+ ("post_rot90", {"rotate90": 1}),
+ ("post_rot180", {"rotate90": 2}),
+ ("post_rot270", {"rotate90": 3}),
+ ("post_invert", {"invert": True}),
+ ("post_rot90_invert", {"rotate90": 1, "invert": True}),
+]
+
+
+def cases() -> list[tuple[str, dict]]:
+ out: list[tuple[str, dict]] = []
+ for name, _desc, program in GALLERY:
+ out.append((f"gallery:{name}", program))
+ for name, shape in OFF_DEFAULTS:
+ out.append((f"params:{name}", prog(shape)))
+ # Composition: the same two shapes under every op, so an op that is wired to
+ # the wrong bitwise operator cannot hide behind a shape that rarely overlaps.
+ for op in OPS:
+ out.append((f"op:{op}", prog(None, layers=[
+ {"op": "set", "shape": {"type": "stripes", "axis": "v", "period": 8, "thickness": 5}},
+ {"op": op, "shape": {"type": "stripes", "axis": "h", "period": 6, "thickness": 4}},
+ ])))
+ # Asymmetric source, so a mirror or rotate that is a no-op is visible.
+ asym = {"type": "triangles", "size": 5, "orientation": "up"}
+ for name, post in POSTS:
+ out.append((f"{name}", prog(asym, post=post)))
+ # Explicit sizing, where the tiling guarantee is deliberately switched off.
+ out.append(("canvas:fixed", prog(
+ {"type": "diagonal", "dx": 1, "dy": 1, "period": 7, "thickness": 3},
+ canvas={"width": 23, "height": 17, "scale": 3, "autoSize": False})))
+ out.append(("canvas:limits", prog(
+ {"type": "checker", "cellW": 1, "cellH": 1},
+ canvas={"width": 129, "height": 65, "scale": 0, "autoSize": False})))
+ return out
+
+
+def main() -> int:
+ check_only = "--check" in sys.argv
+ built = []
+ tiling_failures = []
+
+ for name, program in cases():
+ w, h, scale, buf = render(program)
+ data = encode(w, h, scale, buf)
+ ok, _px, _py = tiles_exactly(program, w, h)
+ if program.get("canvas", {}).get("autoSize", True) and not ok:
+ tiling_failures.append(name)
+ built.append({
+ "name": name,
+ "program": program,
+ "width": w,
+ "height": h,
+ "scale": scale,
+ "ink": sum(buf),
+ "patternData": data,
+ })
+
+ if tiling_failures:
+ print("*** programs with autoSize that do not tile exactly: "
+ f"{', '.join(tiling_failures)} ***")
+ return 1
+
+ doc = {
+ "note": ("Oracle for the parametric DSL. Rendered by tools/dsl_prototype.py, "
+ "which tools/dsl_demo.py verifies tiles exactly. The editor's "
+ "JavaScript must reproduce patternData byte for byte."),
+ "caseCount": len(built),
+ # The glyph tables the editor carries a copy of. Transcribing these by
+ # hand once put a wrong 'D' in the 5x7 font and rewrote half of 3x5; the
+ # text cases caught it, but as "384 lit pixels, oracle says 400", which
+ # names the symptom rather than the cause. Comparing the tables directly
+ # says which glyph.
+ "fonts": {"5x7": FONT_5X7, "3x5": FONT_3X5},
+ "cases": built,
+ }
+
+ if check_only:
+ if not os.path.exists(OUT):
+ print(f"{OUT} is missing — run without --check")
+ return 1
+ if json.load(open(OUT, encoding="utf-8")) != doc:
+ print(f"{OUT} is stale — re-run without --check")
+ return 1
+ print(f"DSL fixtures current {len(built)} programs, all autoSize cases tile exactly")
+ return 0
+
+ os.makedirs(os.path.dirname(OUT), exist_ok=True)
+ with open(OUT, "w", encoding="utf-8") as fh:
+ json.dump(doc, fh, indent=1)
+ fh.write("\n")
+ shapes = {c["program"]["layers"][0]["shape"]["type"] for c in built}
+ print(f"wrote {OUT}")
+ print(f" {len(built)} programs {len(shapes)} distinct primitives in the first layer")
+ print(f" every autoSize program tiles exactly")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/tools/verify-all.sh b/tools/verify-all.sh
index a4641e6..716d290 100755
--- a/tools/verify-all.sh
+++ b/tools/verify-all.sh
@@ -38,6 +38,8 @@ run "codec corpus" python3 tools/gen-codec-fixtures.py --check
run "editor codec vs corpus" node tools/verify-codec.js
run "sampler oracle" python3 tools/gen-sampler-fixtures.py --check
run "editor sampler vs oracle" node tools/verify-sampler.js
+run "DSL oracle" python3 tools/gen-dsl-fixtures.py --check
+run "editor DSL vs oracle" node tools/verify-dsl.js
run "DSL prototype + seam metric" python3 tools/dsl_demo.py
run "router prompt examples" python3 tools/verify-prompt.py
run "map-scale sampling" python3 tools/preview_prototype.py
diff --git a/tools/verify-dsl.js b/tools/verify-dsl.js
new file mode 100644
index 0000000..c233627
--- /dev/null
+++ b/tools/verify-dsl.js
@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/*
+ * Run the EDITOR'S OWN DSL against the Python oracle.
+ *
+ * tools/dsl_prototype.py is the reference implementation and tools/dsl_demo.py
+ * proves 28 programs tile exactly. Neither says anything about the JavaScript a
+ * user's pattern actually goes through. This lifts the real renderer out of
+ * app/patternfront.html and re-renders every program in tests/fixtures/dsl.json,
+ * comparing the encoded result byte for byte.
+ *
+ * Byte-for-byte is the right bar rather than "looks similar": four things in the
+ * Python do not survive a literal translation, and each fails silently.
+ *
+ * round() banker's rounding, so round(2.5) is 2 where Math.round gives 3.
+ * It decides wave offsets and canvas sizing.
+ * % a floor modulo in Python, a remainder in JS. Any expression that
+ * can go negative diverges.
+ * // floors, where |0 truncates toward zero.
+ * _hash2 multiplies by constants near 2^31; a plain * passes 2^53 and drops
+ * low bits, so noise and dot jitter drift apart.
+ *
+ * A pattern that is one pixel different still encodes to a different string, so
+ * any of those shows up here as a mismatch rather than as a subtly wrong export.
+ *
+ * node tools/verify-dsl.js
+ */
+
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const { editorJs, grabFunction, grabConst } = require('./lib/extract');
+
+const ROOT = path.join(__dirname, '..');
+const FIXTURES = path.join(ROOT, 'tests', 'fixtures', 'dsl.json');
+
+if (!fs.existsSync(FIXTURES)) {
+ console.log(`missing ${FIXTURES}`);
+ console.log('run: python3 tools/gen-dsl-fixtures.py');
+ process.exit(2);
+}
+
+const js = editorJs();
+const ctx = {
+ Uint8Array, Error, Math, JSON, Object, String, Array,
+ btoa: s => Buffer.from(s, 'binary').toString('base64'),
+};
+vm.createContext(ctx);
+vm.runInContext([
+ grabConst(js, 'floorMod'),
+ grabFunction(js, 'encodeOF'),
+ grabFunction(js, 'pyRound'),
+ grabFunction(js, 'gcd'),
+ grabFunction(js, 'lcm'),
+ grabFunction(js, 'hash2'),
+ grabConst(js, 'F57'),
+ grabConst(js, 'F35'),
+ grabConst(js, 'DSL_MIN_W'),
+ grabMulti('DSL_SHAPES'),
+ grabConst(js, 'DSL_CANVAS_LOCKED'),
+ grabMulti('DSL_RANGES'),
+ grabFunction(js, 'dslValidateShape'),
+ grabFunction(js, 'dslValidate'),
+ grabFunction(js, 'dslSize'),
+ grabFunction(js, 'dslRender'),
+].join('\n'), ctx);
+
+/** A multi-line `const NAME={...};` — grabConst only handles single lines. */
+function grabMulti(name) {
+ const at = js.indexOf(`const ${name}=`);
+ if (at < 0) throw new Error(`const ${name} not found in the editor`);
+ const { matchBrace } = require('./lib/extract');
+ const open = js.indexOf('{', at);
+ return js.slice(at, matchBrace(js, open) + 1) + ';';
+}
+
+const dslRender = vm.runInContext('dslRender', ctx);
+const encodeOF = vm.runInContext('encodeOF', ctx);
+const pyRound = vm.runInContext('pyRound', ctx);
+
+const corpus = JSON.parse(fs.readFileSync(FIXTURES, 'utf8'));
+const failures = [];
+
+// State the rounding rule as a check, rather than leaving the fixture to imply
+// it. If this is wrong, several cases below fail for a reason nobody would guess.
+for (const [input, want] of [[0.5, 0], [1.5, 2], [2.5, 2], [3.5, 4], [-2.5, -2], [2.4, 2]]) {
+ if (pyRound(input) !== want) {
+ failures.push(`pyRound(${input}) is ${pyRound(input)}, Python gives ${want}`);
+ }
+}
+
+// Compare the glyph tables directly. The editor keeps its own copy, and a bad
+// transcription otherwise surfaces only as a lit-pixel count being off.
+{
+ const F57 = vm.runInContext('F57', ctx), F35 = vm.runInContext('F35', ctx);
+ for (const [label, want, got] of [['5x7', corpus.fonts['5x7'], F57],
+ ['3x5', corpus.fonts['3x5'], F35]]) {
+ const wrong = Object.keys(want)
+ .filter(k => JSON.stringify(want[k]) !== JSON.stringify(got[k]));
+ if (wrong.length) {
+ failures.push(`${label} font: ${wrong.length}/${Object.keys(want).length} `
+ + `glyphs differ from the source table (${wrong.slice(0, 8).join(' ')})`);
+ }
+ }
+}
+
+const primitives = new Set();
+for (const c of corpus.cases) {
+ let got;
+ try { got = dslRender(c.program); }
+ catch (e) { failures.push(`${c.name}: dslRender threw ${e.message}`); continue; }
+
+ if (got.w !== c.width || got.h !== c.height) {
+ failures.push(`${c.name}: sized ${got.w}x${got.h}, oracle says ${c.width}x${c.height}`);
+ continue;
+ }
+ const ink = got.bits.reduce((a, b) => a + b, 0);
+ if (ink !== c.ink) {
+ failures.push(`${c.name}: ${ink} lit pixels, oracle says ${c.ink}`);
+ continue;
+ }
+ const data = encodeOF(got.w, got.h, got.scale, got.bits);
+ if (data !== c.patternData) {
+ failures.push(`${c.name}: encodes to a different pattern `
+ + `(${data.length} vs ${c.patternData.length} chars)`);
+ continue;
+ }
+ for (const l of c.program.layers) primitives.add(l.shape.type);
+}
+
+console.log(`${corpus.cases.length} programs through the editor's own DSL`);
+console.log(` ${primitives.size} primitives exercised, `
+ + `every result compared as encoded patternData`);
+
+if (failures.length) {
+ console.log(`\n*** ${failures.length} FAILURE(S) ***`);
+ for (const f of failures.slice(0, 20)) console.log(` - ${f}`);
+ if (failures.length > 20) console.log(` ... and ${failures.length - 20} more`);
+ process.exit(1);
+}
+console.log(' the shipping renderer agrees with the oracle byte for byte');
+console.log('ALL DSL CHECKS PASSED');