@ev-ry/fx 0.1.0-rc.1

package/src/native-run-shaping.js

@@ -0,0 +1,60 @@
+import { bidi } from './text-direction.js';
+const segmenter = new Intl.Segmenter('fa', { granularity: 'grapheme' });
+
+export function shapeNativeRuns(line, direction) {
+  const embedding = bidi.getEmbeddingLevels(line, direction);
+  const ranks = new Map(bidi.getReorderedIndices(line, embedding).map((index, rank) => [index, rank]));
+  const items = [];
+  let cp = 0;
+  for (const { segment, index } of segmenter.segment(line)) {
+    const level = embedding.levels[index] || 0;
+    let run = items.at(-1);
+    if (!run || run.level !== level) {
+      run = { ch:'', i:cp, utf16:index, level, rank:ranks.get(index) ?? 0, form:0, direction:level & 1 ? 'rtl':'ltr' };
+      items.push(run);
+    }
+    run.ch += segment; run.rank = Math.min(run.rank, ranks.get(index) ?? 0);
+    cp += Array.from(segment).length;
+  }
+  for (const run of items) { run.key = `native:${run.direction}:${run.ch}`; run.rasterText = run.ch; }
+  items.sort((a,b)=>a.rank-b.rank);
+  return { logical:Array.from(line), items };
+}
+
+export function nativeRunMetrics(engine, line, shaping) {
+  const {logical}=shaping;
+  const items=shaping.items.map(run=>({...run,glyph:engine.records.get(`${run.key}:0`)}));
+  const width=items.reduce((sum,item)=>sum+item.glyph.advance,0);
+  const boundary=new Array(logical.length+1), cells=[];
+  let pen=-width/2;
+  for(const item of items){
+    item.x=pen;
+    const advance=item.glyph.advance;
+    engine.rasterizer.configure(item.direction);
+    const segments=Array.from(segmenter.segment(item.ch));
+    let cp=item.i, previous=item.level&1?pen+advance:pen;
+    boundary[cp]=previous;
+    for(let i=0;i<segments.length;i++){
+      const segment=segments[i];
+      const end=segment.index+segment.segment.length;
+      // Canvas exposes whole-run advances, not font ligature caret tables.
+      // Prefix measures are an experimental approximation inside joined clusters.
+      const progress=i===segments.length-1?advance:Math.max(0,Math.min(advance,
+        engine.rasterizer.context.measureText(item.ch.slice(0,end)).width));
+      const x=item.level&1?pen+advance-progress:pen+progress;
+      const length=Array.from(segment.segment).length;
+      for(let j=1;j<length;j++)boundary[cp+j]=previous;
+      boundary[cp+length]=x;
+      cells.push({start:item.utf16+segment.index,end:item.utf16+end,x:Math.min(previous,x),width:Math.abs(x-previous)});
+      previous=x;cp+=length;
+    }
+    pen+=advance;
+  }
+  boundary[0] ??= 0;
+  let offset=0;
+  const utf16Offsets=logical.map(ch=>{const at=offset;offset+=ch.length;return at;});utf16Offsets.push(offset);
+  const lookup=new Map(utf16Offsets.map((offset,index)=>[offset,index]));
+  const stops=Array.from(segmenter.segment(line),s=>s.index);stops.push(line.length);
+  const carets=stops.map(index=>({index,x:boundary[lookup.get(index)]})).sort((a,b)=>a.x-b.x||a.index-b.index);
+  return {text:line,items,boundary,utf16Offsets,carets,cells,height:engine.fontMetrics.height};
+}

package/src/particle-centers.js

@@ -0,0 +1,50 @@
+// Pair only complementary axis-aligned grid triangles. Geometry/UVs stay intact.
+export function particleCenters(THREE,geometry,shape){
+  const position=geometry.getAttribute('position');
+  let cache=geometry.userData.particleCenters;
+  if(shape!=='square'&&(!cache||cache.position!==position||cache.version!==position.version)){
+    const triangle=new Float32Array(position.count*2);
+    for(let i=0;i<position.count;i+=3){
+      const x=(position.getX(i)+position.getX(i+1)+position.getX(i+2))/3;
+      const y=(position.getY(i)+position.getY(i+1)+position.getY(i+2))/3;
+      for(let j=0;j<3;j++){triangle[(i+j)*2]=x;triangle[(i+j)*2+1]=y;}
+    }
+    cache={position,version:position.version,triangle,square:null,pairs:[]};
+    geometry.userData.particleCenters=cache;
+  }
+  if(!cache||cache.position!==position||cache.version!==position.version||shape==='square'&&!cache.square){
+    const cachePairs=[];const triangle=new Float32Array(position.count*2),square=new Float32Array(position.count*2),cells=new Map();
+    for(let i=0;i<position.count;i+=3){
+      const xs=[0,1,2].map(j=>position.getX(i+j)),ys=[0,1,2].map(j=>position.getY(i+j));
+      const x=xs.reduce((a,b)=>a+b)/3,y=ys.reduce((a,b)=>a+b)/3;
+      for(let j=0;j<3;j++)triangle.set([x,y],(i+j)*2);
+      const left=Math.min(...xs),right=Math.max(...xs),bottom=Math.min(...ys),top=Math.max(...ys);
+      if(right===left||top===bottom||xs.some(v=>v!==left&&v!==right)||ys.some(v=>v!==bottom&&v!==top))continue;
+      const corners=new Set(xs.map((v,j)=>(v===right?1:0)+(ys[j]===top?2:0)));
+      if(corners.size!==3)continue;
+      const key=[left,right,bottom,top,position.getZ(i)].join(':');
+      const old=cells.get(key);
+      if(old&&new Set([...old.corners,...corners]).size===4){
+        cells.delete(key);
+        for(const at of [old.index,i])for(let j=0;j<3;j++)square.set([(left+right)/2,(bottom+top)/2],(at+j)*2);
+        cachePairs.push([old.index,i]);
+      }else cells.set(key,{index:i,corners});
+    }
+
+    cache={position,version:position.version,triangle,square,pairs:cachePairs};
+    const paired=new Set(cachePairs.flat());for(let i=0;i<position.count;i+=3)if(!paired.has(i))square.set(triangle.subarray(i*2,(i+3)*2),i*2);
+    geometry.userData.particleCenters=cache;
+  }
+  if(cache.shape!==shape||!geometry.getAttribute('dustCenter')){
+    geometry.setAttribute('dustCenter',new THREE.BufferAttribute(shape==='square'?cache.square:cache.triangle,2));cache.shape=shape;
+  }
+  if(geometry.getAttribute('dustCornerA')&&cache.cornerShape!==shape){
+    for(const name of ['dustCornerA','dustCornerB','dustCornerC']){
+      const a=geometry.getAttribute(name);cache[name]??=a.array.slice();a.array.set(cache[name]);
+      if(shape==='square')for(const [first,second] of cache.pairs)for(let j=0;j<3;j++)a.array.set(cache[name].subarray(first*3,first*3+3),(second+j)*3);
+      a.needsUpdate=true;
+    }
+    cache.cornerShape=shape;
+  }
+  return cache;
+}

package/src/raster-texture-material.js

@@ -0,0 +1,79 @@
+// Text and image surfaces share one texture per raster (not per triangle).
+// References include deletion ghosts, which can outlive their source scene mesh.
+const surfaces=new WeakMap(),materials=new WeakMap();
+export function attachRasterTexture(THREE,material,raster,{lodBias=raster.mask===false?0:-.75}={}){
+  if(!Number.isFinite(lodBias))throw TypeError('A finite raster LOD bias is required');
+  let surface=surfaces.get(raster);
+  if(!surface){
+    const texture=new THREE.DataTexture(raster.rgba,raster.width,raster.height,THREE.RGBAFormat,THREE.UnsignedByteType);
+    if(raster.mask===false)texture.colorSpace=THREE.SRGBColorSpace;
+    // One bilinear mip fetch while moving; the shader adds the adjacent mip only
+    // near the resting pose. Sampling policy never mutates a shared texture.
+    texture.minFilter=THREE.LinearMipmapNearestFilter;texture.magFilter=THREE.LinearFilter;texture.generateMipmaps=true;texture.needsUpdate=true;
+    surface={texture,refs:0,raster};surfaces.set(raster,surface);
+  }
+  material.uniforms.rasterMap={value:surface.texture};
+  material.uniforms.rasterSize={value:new THREE.Vector2(raster.width,raster.height)};
+  material.uniforms.rasterLodBias={value:lodBias};
+  return lease(material,surface);
+}
+// Derivatives describe this triangle's current projected texture footprint.
+// Explicit LOD is core in WebGL2 (Three aliases texture2DLodEXT) and optional in
+// WebGL1. Without it, keep a single conventional texture lookup as a safe fallback.
+const rasterSamplingShader=`
+uniform vec2 rasterSize;
+uniform float rasterLodBias;
+varying float vRasterQuality;
+vec4 thdRasterSample(vec2 uv){
+  #if __VERSION__ >= 300 || defined(GL_EXT_shader_texture_lod)
+    vec2 dx=dFdx(uv*rasterSize),dy=dFdy(uv*rasterSize);
+    float footprint=max(max(dot(dx,dx),dot(dy,dy)),0.00000001);
+    float lastLevel=floor(log2(max(max(rasterSize.x,rasterSize.y),1.0)));
+    float lod=clamp(0.5*log2(footprint)+rasterLodBias,0.0,lastLevel);
+    float primary=floor(lod+0.5);
+    vec4 sampleColor=texture2DLodEXT(rasterMap,uv,primary);
+    float weight=abs(lod-primary)*clamp(vRasterQuality,0.0,1.0);
+    if(weight>0.0){
+      float adjacent=primary<lod?primary+1.0:primary-1.0;
+      sampleColor=mix(sampleColor,texture2DLodEXT(rasterMap,uv,adjacent),weight);
+    }
+    return sampleColor;
+  #else
+    return texture2D(rasterMap,uv);
+  #endif
+}
+`;
+
+/** Add the shared sampler to text/image shaders that already declare rasterMap
+ * and vRasterUV. The default is settled; TriangleEffect supplies each facet's
+ * existing phase without another clock, attribute buffer or per-frame JS work. */
+export function applyRasterSamplingShader(material){
+  material.defines={...material.defines,THD_RASTER_TEXTURE:1};
+  material.extensions={...material.extensions,derivatives:true,shaderTextureLOD:true};
+  material.vertexShader='varying float vRasterQuality;\n'+material.vertexShader;
+  material.vertexShader=material.vertexShader.replace(/void main\(\)\s*\{/,'void main(){ vRasterQuality=1.0;');
+  const main=material.fragmentShader.indexOf('void main');
+  material.fragmentShader=material.fragmentShader.slice(0,main)+rasterSamplingShader+material.fragmentShader.slice(main);
+  material.fragmentShader=material.fragmentShader.replace('texture2D(rasterMap,vRasterUV)','thdRasterSample(vRasterUV)');
+}
+function lease(material,surface){
+  surface.refs++;materials.set(material,surface);let released=false;
+  return ()=>{if(released)return;released=true;materials.delete(material);if(--surface.refs===0){surface.texture.dispose();surfaces.delete(surface.raster);}};
+}
+export function retainRasterTexture(source,target){
+  const surface=materials.get(source);if(!surface)return null;
+  // ShaderMaterial.clone clones texture uniforms. Use the shared source instead
+  // of uploading an identical new image for each partial deletion.
+  if(target.uniforms.rasterMap.value!==surface.texture)target.uniforms.rasterMap.value.dispose();
+  target.uniforms.rasterMap.value=surface.texture;
+  return lease(target,surface);
+}
+export function applyRasterTextureShader(material,{mask=true}={}){
+  material.vertexShader='attribute vec2 rasterUV; varying vec2 vRasterUV;\n'+material.vertexShader;
+  material.vertexShader=material.vertexShader.replace('void main() {','void main() { vRasterUV=rasterUV;');
+  material.fragmentShader='uniform sampler2D rasterMap; varying vec2 vRasterUV;\n'+material.fragmentShader;
+  material.fragmentShader=material.fragmentShader.replace('float coverage =', 'vec4 rasterSample=texture2D(rasterMap,vRasterUV); float coverage =');
+  material.fragmentShader=material.fragmentShader.replace('max(max(vColor.r, vColor.g), vColor.b) * brightness','rasterSample.a * max(max(vColor.r, vColor.g), vColor.b) * min(brightness, 1.0)');
+  if(!mask)material.fragmentShader=material.fragmentShader.replace('vec4(tint * min(1.0, diffuse + sheen), coverage)', 'vec4(rasterSample.rgb * tint * min(1.0, diffuse + sheen), coverage)');
+  applyRasterSamplingShader(material);
+}

package/src/raster-texture-mesh.js

@@ -0,0 +1,35 @@
+// Shared raster -> UV triangle grid for font masks and RGBA images. No color
+// averaging, alpha quantization or triangle merging. All filtering is on the GPU.
+export function rasterToTextureMesh(rgba,width,height,divisions,{filterRadius=.5,aspect=width/height}={}){
+  if(!Number.isInteger(width)||width<1||!Number.isInteger(height)||height<1||rgba.length!==width*height*4)throw RangeError('Invalid raster');
+  if(!Number.isInteger(divisions)||divisions<1||divisions>256)throw RangeError('Invalid divisions');
+  if(!Number.isFinite(filterRadius)||filterRadius<.5)throw RangeError('Invalid texture filter support');
+  if(!Number.isFinite(aspect)||aspect<=0)throw RangeError('Invalid grid aspect');
+  const rows=divisions,columns=Math.max(1,Math.round(aspect*rows));
+  const cw=width/columns,ch=height/rows,occupied=new Uint8Array(rows*columns);
+  // Conservative filter support: half a texel for bilinear filtering by default;
+  // image surfaces may request the wider footprint used by minified mipmaps.
+  // A thin line or isolated pixel cannot be lost to sparse point sampling.
+  for(let y=0;y<height;y++)for(let x=0;x<width;x++){
+    if(!rgba[(y*width+x)*4+3])continue;
+    const x0=Math.max(0,x-filterRadius),x1=Math.min(width,x+1+filterRadius),y0=Math.max(0,y-filterRadius),y1=Math.min(height,y+1+filterRadius);
+    for(let row=Math.floor(y0/ch);row<=Math.min(rows-1,Math.floor(y1/ch));row++)for(let col=Math.floor(x0/cw);col<=Math.min(columns-1,Math.floor(x1/cw));col++){
+      const at=row*columns+col;if(occupied[at]===3)continue;
+      const left=Math.max(0,x0/cw-col),right=Math.min(1,x1/cw-col),top=Math.max(0,y0/ch-row),bottom=Math.min(1,y1/ch-row);
+      const even=(row+col)%2===0;
+      if(even?left+top<=1:top<=right)occupied[at]|=1;
+      if(even?right+bottom>=1:bottom>=left)occupied[at]|=2;
+    }
+  }
+  let triangleCount=0;for(const bits of occupied)triangleCount+=(bits&1?1:0)+(bits&2?1:0);
+  const coordinates=new Float64Array(triangleCount*6),uvs=new Float32Array(triangleCount*6),coverage=new Uint8Array(triangleCount).fill(6);
+  let at=0;
+  for(let row=0;row<rows;row++)for(let col=0;col<columns;col++){
+    const left=col*cw,right=(col+1)*cw,top=row*ch,bottom=(row+1)*ch,even=(row+col)%2===0;
+    for(let side=0;side<2;side++)if(occupied[row*columns+col]&(1<<side)){
+      const points=even?[right,top,side?right:left,bottom,left,side?bottom:top]:[left,top,side?left:right,bottom,right,side?bottom:top];
+      coordinates.set(points,at);for(let i=0;i<6;i++)uvs[at+i]=points[i]/(i%2?height:width);at+=6;
+    }
+  }
+  return {coordinates,uvs,coverage,triangleCount};
+}

package/src/render-owner.js

@@ -0,0 +1,63 @@
+import {createViewportRenderOwner} from './viewport-render-owner.js';
+
+// Shared GPU ownership, independent of component factories. Local 2D
+// presentation canvases preserve DOM stacking and clipping of each surface.
+export function createRenderOwner(THREE,document,{presentation='local',...options}={}){
+  if(presentation==='viewport')return createViewportRenderOwner(THREE,document,options);
+  if(presentation!=='local')throw TypeError('Invalid canvas presentation');
+  if(!THREE?.WebGLRenderer||!document?.defaultView)throw TypeError('THREE and a window document required');
+  let renderer=null,disposed=false,lost=false,w=0,h=0,dpr=0,copies=0,copyMs=0,renderMs=0,created=0;
+  const leases=new Set(),handles=new Set();
+  function broadcast(){lost=true;for(const lease of leases)lease.domElement.dispatchEvent(new document.defaultView.Event('webglcontextlost',{cancelable:true}));}
+  function ensure(){
+    if(disposed||lost)throw Error('Shared renderer unavailable');
+    if(!renderer){renderer=new THREE.WebGLRenderer({antialias:true,alpha:true});created++;renderer.domElement.addEventListener('webglcontextlost',onLoss);}
+  }
+  function onLoss(event){event.preventDefault();broadcast();}
+  const Namespace={...THREE,WebGLRenderer:class{
+    constructor(){
+      ensure();this.domElement=document.createElement('canvas');this.context=this.domElement.getContext('2d');
+      if(!this.context)throw Error('2D presentation unavailable');
+      this.width=300;this.height=150;this.ratio=1;this.dead=false;leases.add(this);
+    }
+    setPixelRatio(value){this.ratio=value;this.setSize(this.width,this.height,false);}
+    setSize(width,height){
+      this.width=width;this.height=height;
+      const pw=Math.floor(width*this.ratio),ph=Math.floor(height*this.ratio);
+      if(this.domElement.width!==pw)this.domElement.width=pw;
+      if(this.domElement.height!==ph)this.domElement.height=ph;
+    }
+    render(scene,camera){
+      ensure();if(this.dead)throw Error('Presentation disposed');
+      if(dpr!==this.ratio){renderer.setPixelRatio(this.ratio);dpr=this.ratio;}
+      if(w!==this.width||h!==this.height){renderer.setSize(this.width,this.height,false);w=this.width;h=this.height;}
+      const t=performance.now();renderer.render(scene,camera);renderMs+=performance.now()-t;
+      const start=performance.now();this.context.clearRect(0,0,this.domElement.width,this.domElement.height);
+      this.context.drawImage(renderer.domElement,0,0);copyMs+=performance.now()-start;copies++;
+    }
+    dispose(){if(this.dead)return;this.dead=true;leases.delete(this);this.domElement.width=this.domElement.height=0;}
+    forceContextLoss(){} // A lease cannot destroy a peer's context.
+  }};
+  function create(factory,host,options){
+      if(disposed)throw Error('Shared owner disposed');
+      if(host?.ownerDocument!==document)throw TypeError('Host must belong to the owner document');
+      const control=factory(host,Namespace,options),destroy=control.destroy;
+      handles.add(control);control.destroy=()=>{handles.delete(control);destroy();};return control;
+  }
+  return {create,
+    refresh(){if(disposed)throw Error('Shared owner disposed');for(const control of handles)control.refresh?.();},
+    stats:()=>({disposed,lost,contexts:renderer&&!disposed?1:0,created,controls:handles.size,leases:leases.size,copies,copyMs,renderMs,geometries:renderer?.info.memory.geometries||0}),
+    destroy(){
+      if(disposed)return;disposed=true;
+      const errors=[];
+      for(const control of [...handles])try{control.destroy();}catch(error){errors.push(error);}
+      if(renderer){
+        renderer.domElement.removeEventListener('webglcontextlost',onLoss);
+        try{renderer.dispose();}catch(error){errors.push(error);}
+        try{renderer.forceContextLoss();}catch(error){errors.push(error);}
+      }
+      if(errors.length)throw new AggregateError(errors,'Hybrid owner cleanup failed');
+    }
+  };
+}
+

package/src/runtime-font-engine.js

@@ -0,0 +1,242 @@
+import { documentDirection } from './text-direction.js';
+import { FontMeshEngine, shapeLine } from './font-mesh-engine.js';
+import { FontRasterizer } from './font-rasterizer.js';
+import { rasterToTriangles } from './mesh-generator-core.js';
+import { shapeNativeRuns, nativeRunMetrics } from './native-run-shaping.js';
+import { rasterToTextureMesh } from './raster-texture-mesh.js';
+import { normalizeTextMeshOptions, textDivisionsForSize } from './text-mesh-density.js';
+
+let familySequence = 0;
+
+export class RuntimeFontEngine extends FontMeshEngine {
+  constructor({ textRendering = 'coverage', divisions = textRendering === 'texture' ? 'auto' : 48, weight = 400, cacheLimit = 512, cacheBudgetBytes = 8 * 1024 * 1024, ...options } = {}) {
+    super(options);
+    normalizeTextMeshOptions({textRendering,divisions});
+    this.divisionMode=divisions;
+    this.divisions = divisions==='auto'?textDivisionsForSize(16):divisions;
+    this.displayFontSize=null;this.densityChanges=0;
+    this.textRendering=textRendering;
+    this.weight = weight;
+    if (!Number.isInteger(cacheLimit) || cacheLimit < 0 || !Number.isFinite(cacheBudgetBytes) || cacheBudgetBytes < 0) throw new RangeError('Invalid cache limits');
+    this.cacheLimit = cacheLimit;
+    this.cacheBudgetBytes = Math.floor(cacheBudgetBytes);
+    this.cacheBytes = 0; this.activeBytes = 0; this.evicted = 0;
+    this.generated = 0;
+    this.generationMs = 0;
+    this.lastUsed = new Map();
+    this.clock = 0;
+  }
+
+  async loadFont(source) {
+    const started = performance.now();
+    let buffer;
+    if (source instanceof Blob) buffer = await source.arrayBuffer();
+    else {
+      const response = await fetch(source);
+      if (!response.ok) throw new Error(`بارگذاری فونت ناموفق بود (${response.status}).`);
+      buffer = await response.arrayBuffer();
+    }
+    const family = `THDRuntime${++familySequence}`;
+    const nextFace = await new FontFace(family, buffer, { weight: '100 900' }).load();
+    if (this.face) document.fonts.delete(this.face);
+    this.face = nextFace; document.fonts.add(nextFace);
+    this.rasterizer = new FontRasterizer(family, this.weight);
+    this.clearMeshes();
+    const ascent = this.rasterizer.ascent + 2, descent = this.rasterizer.descent + 2;
+    this.fontMetrics = { ascent, descent, height: ascent + descent };
+    this.lineAdvance = this.fontMetrics.height * Math.max(1, this.lineHeight);
+    this.fontLoadMs = performance.now() - started;
+    return { bytes: buffer.byteLength, fontLoadMs: this.fontLoadMs };
+  }
+
+  clearMeshes() {
+    this.meshRevision = (this.meshRevision || 0) + 1;
+    this.records.clear(); this.lastUsed.clear(); this.lineCache.clear(); this.cachedLayout = null;
+    this.generated = 0; this.generationMs = 0;
+    this.cacheBytes = 0; this.activeBytes = 0; this.evicted = 0;
+    this.rasterizer?.cache.clear();
+  }
+
+  setDivisions(value) {
+    normalizeTextMeshOptions({textRendering:this.textRendering,divisions:value});
+    this.divisionMode=value;
+    const next=value==='auto'?textDivisionsForSize(this.displayFontSize):value;
+    if (next === this.divisions) return;
+    this.divisions = next; this.clearMeshes();
+  }
+
+  setDisplayFontSize(pixels) {
+    if(this.divisionMode!=='auto'||!Number.isFinite(pixels)||pixels<=0)return false;
+    const next=textDivisionsForSize(pixels,this.displayFontSize===null?null:this.divisions);
+    this.displayFontSize=pixels;
+    if(next===this.divisions)return false;
+    this.divisions=next;this.densityChanges++;
+    // Keep source rasters and GPU texture identity. Replace glyph geometry lazily;
+    // the scene can display its previous records until preparation commits.
+    this.meshRevision=(this.meshRevision||0)+1;
+    this.lineCache.clear();this.cachedLayout=null;
+    return true;
+  }
+
+  setInputLayout(direction, alignment, width = 0) {
+    if (!['auto','ltr','rtl'].includes(direction) || !['left','right','auto'].includes(alignment) || !Number.isFinite(width) || width < 0) throw new TypeError('Invalid input layout');
+    if (this.inputDirection === direction && this.inputAlignment === alignment && this.inputWidth === width) return false;
+    this.inputDirection = direction; this.inputAlignment = alignment; this.inputWidth = width;
+    this.lineCache.clear(); this.cachedLayout = null;
+    this.meshRevision = (this.meshRevision || 0) + 1;
+    return true;
+  }
+
+  shape(line) {
+    const direction = this.inputDirection === 'auto' ? undefined : this.inputDirection;
+    return this.nativeShaping ? shapeNativeRuns(line, direction) : shapeLine(line, direction);
+  }
+  metricsForLine(line, shaping) {
+    const metrics = this.nativeShaping ? nativeRunMetrics(this,line,shaping) : super.layoutLine(line, shaping);
+    if (this.inputAlignment) {
+      let left = Infinity, right = -Infinity;
+      for (const item of metrics.items) {
+        left = Math.min(left, item.x); right = Math.max(right, item.x + (item.glyph?.advance || 0));
+      }
+      if (!metrics.items.length) left = right = 0;
+      const rightAligned = this.inputAlignment === 'auto' ? documentDirection(line, 'ltr') === 'rtl' : this.inputAlignment === 'right';
+      const shift = rightAligned ? this.inputWidth / 2 - right : -this.inputWidth / 2 - left;
+      for (const item of metrics.items) item.x += shift;
+      metrics.boundary = metrics.boundary.map(x => x + shift);
+      for (const edges of metrics.caretEdges?.values() || []) for (const edge of edges) edge.x += shift;
+      for (const caret of metrics.carets) caret.x += shift;
+      for (const cell of metrics.cells || []) cell.x += shift;
+    }
+    return metrics;
+  }
+
+  selectionRects(text,start,end) {
+    if (!this.nativeShaping) return super.selectionRects(text,start,end);
+    if(start>=end)return [];
+    const result=[];
+    for(const entry of this.layout(text).entries){
+      const box=this.fontLineBox(entry.baseline);
+      const cells=entry.metrics.cells.filter(c=>c.start+entry.offset<end && c.end+entry.offset>start && c.width>0).sort((a,b)=>a.x-b.x);
+      let run;
+      for(const cell of cells){
+        const x=cell.x*this.scale,right=(cell.x+cell.width)*this.scale;
+        if(run && x<=run.x+run.width+1e-6)run.width=Math.max(right,run.x+run.width)-run.x;
+        else {run={x,y:box.bottom,width:right-x,height:box.height};result.push(run);}
+      }
+    }
+    return result;
+  }
+
+  layoutLine(line) {
+    if (!this.rasterizer) throw new Error('ابتدا فایل فونت را بارگذاری کنید.');
+    const shaping = this.shape(line);
+    for (const item of shaping.items) {
+      if (item.control) continue;
+      this.ensureGlyph(item);
+    }
+    return this.metricsForLine(line, shaping);
+  }
+
+  ensureGlyph(item) {
+      const key = `${item.key}:${item.form}`;
+      this.lastUsed.delete(key); this.lastUsed.set(key, ++this.clock);
+      const previous=this.records.get(key);
+      if (previous && (this.textRendering!=='texture'||previous.divisions===this.divisions)) return;
+      const started = performance.now();
+      const raster = previous?.rasterSurface?{...previous.rasterSurface,baseline:previous.rasterBaseline,advance:previous.advance,drawOffsetX:previous.drawOffsetX}:this.rasterizer.raster(item.rasterText, item.direction);
+      const textured=this.textRendering==='texture';
+      const meshData = textured?rasterToTextureMesh(raster.rgba,raster.width,raster.height,this.divisions):rasterToTriangles(raster.rgba, raster.width, raster.height, this.divisions, true, 10);
+      // Raster canvases can grow for unusual marks; align their real baseline
+      // with the fixed font-wide origin used by selection and caret.
+      const shift = this.fontMetrics.ascent - raster.baseline;
+      if (shift) for (let i = 1; i < meshData.coordinates.length; i += 2) meshData.coordinates[i] += shift;
+      const byteLength = meshData.coordinates.byteLength + meshData.coverage.byteLength + (textured?meshData.uvs.byteLength+raster.rgba.byteLength:0);
+      this.cacheBytes += byteLength-(previous?.byteLength||0);
+      this.records.set(key, { cacheKey: key, byteLength, meshData, width: raster.width, height: this.fontMetrics.height,
+        baseline: this.fontMetrics.ascent, advance: raster.advance, drawOffsetX: raster.drawOffsetX,
+        ...(textured?{divisions:this.divisions,rasterBaseline:raster.baseline,rasterSurface:previous?.rasterSurface||{width:raster.width,height:raster.height,rgba:raster.rgba}}:{}) });
+      this.rasterizer.cache.clear(); // The optional texture is owned/accounted by its glyph record.
+      this.generated++;
+      this.generationMs += performance.now() - started;
+  }
+
+  async prepareText(text, { cancelled = () => false, yieldTask = () => new Promise(resolve => setTimeout(resolve, 0)), budgetMs = 4, buildGeometry = true } = {}) {
+    const revision = this.meshRevision;
+    const stale = () => cancelled() || revision !== this.meshRevision;
+    let started = performance.now(), sliceStart = started, slices = 0, maxSliceMs = 0;
+    const nextCache = new Map();
+    try {
+    for (const line of text.split(/\r?\n/u)) {
+      if (stale()) return null;
+      let metrics = nextCache.get(line) || this.lineCache.get(line);
+      if (!metrics) {
+        const shaping = this.shape(line);
+        for (const item of shaping.items) {
+          if (stale()) return null;
+          if (!item.control) this.ensureGlyph(item);
+          if (performance.now() - sliceStart >= budgetMs) {
+            maxSliceMs = Math.max(maxSliceMs, performance.now() - sliceStart);
+            slices++; await yieldTask(); sliceStart = performance.now();
+          }
+        }
+        if (stale()) return null;
+        metrics = this.metricsForLine(line, shaping);
+      }
+      // Prepare each line's GPU arrays before the atomic scene update.
+      if (buildGeometry) this.buildLine(metrics);
+      nextCache.set(line, metrics);
+      if (performance.now() - sliceStart >= budgetMs) {
+        maxSliceMs = Math.max(maxSliceMs, performance.now() - sliceStart);
+        slices++; await yieldTask(); sliceStart = performance.now();
+      }
+    }
+    if (stale()) return null;
+    maxSliceMs = Math.max(maxSliceMs, performance.now() - sliceStart);
+    this.lineCache = nextCache; this.cachedLayout = null;
+    return { elapsedMs: performance.now() - started, slices, maxSliceMs };
+    } finally {
+      // Cancelled jobs may have populated the glyph cache; trim them too.
+      if (revision === this.meshRevision) this.trimCache();
+    }
+  }
+
+  layout(text) {
+    if (this.cachedLayout?.text === text) return this.cachedLayout;
+    const result = super.layout(text);
+    this.trimCache();
+    return result;
+  }
+
+  trimCache() {
+    // Reuse shaped metrics, including unchanged lines; no bidi/layout pass here.
+    const active = new Set();
+    for (const metrics of this.lineCache.values()) for (const { glyph } of metrics.items) {
+      if (glyph?.cacheKey && this.records.get(glyph.cacheKey) === glyph) active.add(glyph.cacheKey);
+    }
+    this.activeBytes = 0;
+    for (const key of active) {
+      this.activeBytes += this.records.get(key).byteLength;
+      this.lastUsed.delete(key); this.lastUsed.set(key, ++this.clock);
+    }
+    // Map insertion order is LRU; count remains a guard for zero-byte glyphs.
+    for (const key of this.lastUsed.keys()) {
+      if (this.cacheBytes <= this.cacheBudgetBytes && this.records.size <= this.cacheLimit) break;
+      if (active.has(key)) continue;
+      const record = this.records.get(key);
+      if (record) { this.cacheBytes -= record.byteLength; this.records.delete(key); this.evicted++; }
+      this.lastUsed.delete(key);
+    }
+  }
+
+  cacheStats() {
+    return { bytes: this.cacheBytes, activeBytes: this.activeBytes,
+      inactiveBytes: this.cacheBytes - this.activeBytes, budgetBytes: this.cacheBudgetBytes,
+      overBudgetBytes: Math.max(0, this.cacheBytes - this.cacheBudgetBytes), evicted: this.evicted };
+  }
+
+  dispose() {
+    this.clearMeshes();
+    if (this.face) document.fonts.delete(this.face);
+    this.face = null; this.rasterizer = null;
+  }
+}

package/src/runtime-lifecycle.js

@@ -0,0 +1,26 @@
+// Resource ownership only. No text, font, form or renderer dependencies.
+export function createLifecycle() {
+  let disposed = false;
+  const cleanups = [];
+  function own(cleanup) {
+    if (disposed) cleanup(); else cleanups.push(cleanup);
+  }
+  return {
+    get disposed() { return disposed; },
+    own,
+    listen(target, type, callback, options) {
+      if (!target || disposed) return;
+      target.addEventListener(type, callback, options);
+      own(() => target.removeEventListener(type, callback, options));
+    },
+    destroy() {
+      if (disposed) return;
+      disposed = true;
+      const errors = [];
+      for (const cleanup of cleanups.splice(0).reverse()) {
+        try { cleanup(); } catch (error) { errors.push(error); }
+      }
+      if (errors.length) throw new AggregateError(errors, 'Runtime cleanup failed');
+    },
+  };
+}

package/src/text-direction.js

@@ -0,0 +1,25 @@
+import bidiFactory from '../assets/vendor/bidi.min.js';
+
+// bidi-js 1.0.3, Unicode 13 UAX #9; vendored locally with its MIT license.
+export const bidi = bidiFactory();
+export const isBidiControl = ch => /^[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]$/u.test(ch);
+
+// Horizontal keyboard navigation deliberately follows the whole document.
+export function documentDirection(text, fallback = 'rtl') {
+  for (const ch of text) {
+    const type = bidi.getBidiCharTypeName(ch);
+    if (type === 'L') return 'ltr';
+    if (type === 'R' || type === 'AL') return 'rtl';
+  }
+  return fallback;
+}
+
+// UTF-16 logical runs for visual effects; neutral characters inherit resolved bidi levels.
+export function directionalRanges(text,start,end,base='auto'){
+  const {levels}=bidi.getEmbeddingLevels(text,base==='auto'?undefined:base),ranges=[];
+  for(let i=start;i<end;i++){
+    const direction=levels[i]%2?'rtl':'ltr',last=ranges.at(-1);
+    if(last?.direction===direction)last.end=i+1;else ranges.push({start:i,end:i+1,direction});
+  }
+  return ranges;
+}