longpipe 0.0.14 → 0.0.16

package/dist/chunk-O4OF2WRO.js

@@ -0,0 +1,33 @@
+var a={rnnoise:{wasm:"rnnoise.wasm",weights:null,scaleIn:32768,scaleOut:30517578125e-15,needsSimd:false,exports:{malloc:"malloc",create:"rn_create",process:"rn_process"}},dfn:{wasm:"dfn.wasm",weights:"dfn_weights.pack",scaleIn:1,scaleOut:1,needsSimd:true,exports:{malloc:"df_lite_malloc",create:"df_lite_create",process:"df_lite_process",setBeta:"df_lite_set_beta",setGruLeak:"df_lite_set_gru_leak"}},dfnint8:{wasm:"dfn.wasm",weights:"dfn_weights_int8.pack",scaleIn:1,scaleOut:1,needsSimd:true,exports:{malloc:"df_lite_malloc",create:"df_lite_create_i8",process:"df_lite_process",setBeta:"df_lite_set_beta",setGruLeak:"df_lite_set_gru_leak"}}},_={high:"dfn",mid:"dfnint8",low:"rnnoise"},b=["high","mid","low"];function M(t){return b.includes(t)}function c(t){return M(t)?_[t]:t}function m(t,e){return `${t.replace(/\/$/,"")}/${e}`}async function p(t){let e=await fetch(t);if(!e.ok)throw new Error(`audio asset fetch failed: ${e.status} ${t}`);return e.arrayBuffer()}async function f(t,e){let r=a[t],[s,o]=await Promise.all([p(m(e,r.wasm)),r.weights?p(m(e,r.weights)):Promise.resolve(null)]);return {wasmBytes:s,weights:o}}function l(){try{return WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,10,22,1,20,0,253,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11]))}catch{return  false}}var k=1.3,x=64,S=3,R=`
+self.onmessage = async (e) => {
+  const { wasmUrl, iters, rounds, budget } = e.data
+  try {
+    const res = await fetch(wasmUrl)
+    if (!res.ok) throw new Error(res.status + ' ' + wasmUrl)
+    const module = await WebAssembly.compile(await res.arrayBuffer())
+    const imports = {}
+    for (const im of WebAssembly.Module.imports(module)) {
+      ;(imports[im.module] = imports[im.module] || {})
+      if (im.kind === 'function') imports[im.module][im.name] = () => 0
+    }
+    const ex = new WebAssembly.Instance(module, imports).exports
+    const best = (fn) => {
+      fn(iters)                                   // warm up
+      let b = Infinity
+      for (let r = 0; r < rounds; r++) {
+        const t = performance.now()
+        fn(iters)
+        b = Math.min(b, (performance.now() - t) / iters)
+      }
+      return b
+    }
+    const dfnMs = best(ex.calibrate_f32)
+    const int8Ms = ex.calibrate_i8 ? best(ex.calibrate_i8) : Infinity
+    const model = dfnMs <= budget ? 'dfn' : int8Ms <= budget ? 'dfnint8' : 'rnnoise'
+    self.postMessage({ model, dfnMs, int8Ms })
+  } catch (err) {
+    self.postMessage({ error: (err && err.message) || String(err) })
+  }
+}
+`;async function g(t,e){if(!l())return "rnnoise";let r=`${t.replace(/\/$/,"")}/${a.dfn.wasm}`,s=null,o=null;try{s=URL.createObjectURL(new Blob([R],{type:"application/javascript"})),o=new Worker(s);let i=await new Promise((h,n)=>{o.onmessage=u=>h(u.data),o.onerror=u=>n(new Error(u.message||"probe worker error")),o.postMessage({wasmUrl:r,iters:x,rounds:S,budget:k});});if(i.error)throw new Error(i.error);return i.model??"rnnoise"}catch(i){return e?.(`audio tier probe failed (${i.message??String(i)}); using rnnoise`),"rnnoise"}finally{o?.terminate(),s&&URL.revokeObjectURL(s);}}var d='var b=Object.defineProperty;var y=(u,a,i)=>a in u?b(u,a,{enumerable:!0,configurable:!0,writable:!0,value:i}):u[a]=i;var r=(u,a,i)=>y(u,typeof a!="symbol"?a+"":a,i);var f={rnnoise:{wasm:"rnnoise.wasm",weights:null,scaleIn:32768,scaleOut:30517578125e-15,needsSimd:!1,exports:{malloc:"malloc",create:"rn_create",process:"rn_process"}},dfn:{wasm:"dfn.wasm",weights:"dfn_weights.pack",scaleIn:1,scaleOut:1,needsSimd:!0,exports:{malloc:"df_lite_malloc",create:"df_lite_create",process:"df_lite_process",setBeta:"df_lite_set_beta",setGruLeak:"df_lite_set_gru_leak"}},dfnint8:{wasm:"dfn.wasm",weights:"dfn_weights_int8.pack",scaleIn:1,scaleOut:1,needsSimd:!0,exports:{malloc:"df_lite_malloc",create:"df_lite_create_i8",process:"df_lite_process",setBeta:"df_lite_set_beta",setGruLeak:"df_lite_set_gru_leak"}}};var c=4096,m=class extends AudioWorkletProcessor{constructor(i){super();r(this,"cfg");r(this,"mem");r(this,"run");r(this,"state",0);r(this,"inPtr",0);r(this,"outPtr",0);r(this,"setBeta",null);r(this,"setGruLeak",null);r(this,"resample",!1);r(this,"rsPush",null);r(this,"inRs",0);r(this,"outRs",0);r(this,"rsDevInPtr",0);r(this,"rsOutPtr",0);r(this,"enabled");r(this,"model");r(this,"inAcc",new Float32Array(480));r(this,"inFill",0);r(this,"outRing",new Float32Array(4096));r(this,"outRead",0);r(this,"outWrite",0);r(this,"outCount",0);r(this,"primed",!1);r(this,"now");r(this,"times",new Float32Array(256));r(this,"tIdx",0);r(this,"hops",0);r(this,"_f32",null);let o=i.processorOptions;this.model=o.model,this.enabled=o.enabled,this.cfg=f[o.model];try{let t=this.instantiate(o.wasmBytes),e=n=>n?t[n]:void 0;this.mem=t.memory;let s=t[this.cfg.exports.malloc];if(this.run=t[this.cfg.exports.process],this.inPtr=s(480*4),this.outPtr=s(480*4),o.weights?this.state=t[this.cfg.exports.create](this.upload(s,o.weights),o.weights.byteLength):this.state=t[this.cfg.exports.create](),this.setBeta=e(this.cfg.exports.setBeta)??null,this.setGruLeak=e(this.cfg.exports.setGruLeak)??null,this.setBeta&&(o.postFilterBeta??0)>0&&this.setBeta(this.state,o.postFilterBeta),this.setGruLeak&&(o.gruLeak??1)<1&&this.setGruLeak(this.state,o.gruLeak),sampleRate!==48e3){let n=t.df_resampler_create;this.rsPush=t.df_resampler_push??null,n&&this.rsPush?(this.resample=!0,this.inRs=n(sampleRate,48e3),this.outRs=n(48e3,sampleRate),this.rsDevInPtr=s(256*4),this.rsOutPtr=s(c*4)):this.post({type:"error",message:`${o.model} can\'t resample ${sampleRate}\\u219248000 Hz; needs a 48 kHz AudioContext`})}}catch(t){let e=t;this.post({type:"error",message:`denoise init failed: ${e.message??String(t)}${e.stack?`\n`+e.stack:""}`})}this.now=typeof performance<"u"&&performance.now?()=>performance.now():null,this.port.onmessage=t=>{let e=t.data;e.type==="enabled"?this.enabled=e.value:e.type==="config"&&(this.setBeta&&e.postFilterBeta!=null&&this.setBeta(this.state,e.postFilterBeta),this.setGruLeak&&e.gruLeak!=null&&this.setGruLeak(this.state,e.gruLeak))},this.post({type:"ready"})}instantiate(i){var e;let o=new WebAssembly.Module(i),t={};for(let s of WebAssembly.Module.imports(o))t[e=s.module]??(t[e]={}),s.kind==="function"?t[s.module][s.name]=()=>0:s.kind==="memory"?t[s.module][s.name]=new WebAssembly.Memory({initial:256}):s.kind==="table"?t[s.module][s.name]=new WebAssembly.Table({initial:0,element:"anyfunc"}):s.kind==="global"&&(t[s.module][s.name]=new WebAssembly.Global({value:"i32",mutable:!1},0));return new WebAssembly.Instance(o,t).exports}upload(i,o){let t=new Uint8Array(o),e=i(t.length);return new Uint8Array(this.mem.buffer).set(t,e),e}heap(){return(!this._f32||this._f32.buffer!==this.mem.buffer)&&(this._f32=new Float32Array(this.mem.buffer)),this._f32}post(i){this.port.postMessage(i)}pushOut(i){this.outRing[this.outWrite]=i,this.outWrite=(this.outWrite+1)%this.outRing.length,this.outCount++}feed48k(i,o){for(let t=0;t<o;t++)this.inAcc[this.inFill++]=i[t],this.inFill===480&&(this.runHop(),this.inFill=0)}runHop(){let i=this.heap(),o=this.inPtr>>2;for(let e=0;e<480;e++)i[o+e]=this.inAcc[e]*this.cfg.scaleIn;let t=this.now?this.now():0;if(this.run(this.state,this.inPtr,this.outPtr),this.now&&(this.times[this.tIdx=this.tIdx+1&255]=this.now()-t),this.resample&&this.rsPush){let e=this.rsPush(this.outRs,this.outPtr,480,this.rsOutPtr,c);i=this.heap();let s=this.rsOutPtr>>2;for(let n=0;n<e;n++)this.pushOut(i[s+n])}else{let e=this.outPtr>>2;for(let s=0;s<480;s++)this.pushOut(i[e+s]*this.cfg.scaleOut)}++this.hops>=50&&(this.reportStats(),this.hops=0)}reportStats(){let i=Array.from(this.times).filter(e=>e>0).sort((e,s)=>e-s),o=e=>i.length?i[Math.min(i.length-1,Math.floor(e*i.length))]:null,t={model:this.model,p50Ms:this.now?o(.5):null,p95Ms:this.now?o(.95):null,latencyMs:this.outCount/sampleRate*1e3,active:this.enabled&&this.state!==0,sampleRate};this.post({type:"stats",stats:t})}process(i,o){let t=i[0]?.[0],e=o[0]?.[0];if(!e)return!0;let s=e.length;if(!t||!this.enabled||this.state===0)return t&&!this.enabled?e.set(t):e.fill(0),!0;if(this.resample&&this.rsPush){let n=this.heap(),g=this.rsDevInPtr>>2;for(let h=0;h<s;h++)n[g+h]=t[h];let d=this.rsPush(this.inRs,this.rsDevInPtr,s,this.rsOutPtr,c);n=this.heap(),this.feed48k(n.subarray(this.rsOutPtr>>2,(this.rsOutPtr>>2)+d),d)}else this.feed48k(t,s);if(!this.primed)if(this.outCount>=480)this.primed=!0;else return e.fill(0),!0;if(this.outCount>=s)for(let n=0;n<s;n++)e[n]=this.outRing[this.outRead],this.outRead=(this.outRead+1)%this.outRing.length,this.outCount--;else e.fill(0);return!0}};registerProcessor("denoise",m);\n';var w="https://cdn.longpipe.dev/models/v/0.0.5/";var E=.03,v=.995,y=class{constructor(e,r={}){this.opts=r;this.ctx=new AudioContext({sampleRate:48e3}),this.source=this.ctx.createMediaStreamSource(new MediaStream([e])),this.dest=this.ctx.createMediaStreamDestination(),this.outputTrack=this.dest.stream.getAudioTracks()[0],this.resume().catch(()=>{}),this.source.connect(this.dest),this.ready=this.init().then(()=>this.node!==null,s=>(this.opts.onError?.(`audio denoise init failed: ${s.message??String(s)}`),false));}opts;outputTrack;ready;ctx;source;dest;node=null;model=null;latestStats=null;destroyed=false;resolveExplicit(){let e=c(this.opts.model);return a[e].needsSimd&&!l()?(this.opts.onError?.(`${e} needs wasm SIMD; falling back to rnnoise`),"rnnoise"):e}async init(){let e=this.opts.weightsBaseUrl??w,r=(this.opts.model??"auto")==="auto"?await g(e,this.opts.onError):this.resolveExplicit();this.model=r;let s=await f(r,e);if(await this.ctx.audioWorklet.addModule(L()),this.destroyed)return;let o={model:r,wasmBytes:s.wasmBytes,weights:s.weights,enabled:this.opts.enabled??true,postFilterBeta:this.opts.postFilterBeta??E,gruLeak:this.opts.gruLeak??v},i=new AudioWorkletNode(this.ctx,"denoise",{numberOfInputs:1,numberOfOutputs:1,outputChannelCount:[1],processorOptions:o});i.port.onmessage=h=>{let n=h.data;n.type==="stats"?this.latestStats=n.stats:n.type==="error"?this.opts.onError?.(n.message):n.type==="ready"&&this.opts.onReady?.();},this.node=i,this.source.disconnect(this.dest),this.source.connect(i).connect(this.dest);}setEnabled(e){this.node?.port.postMessage({type:"enabled",value:e});}setConfig(e){this.node?.port.postMessage({type:"config",...e});}getStats(){return this.latestStats}async resume(){this.destroyed||this.ctx.state!=="suspended"||await this.ctx.resume();}destroy(){this.destroyed=true;try{this.node?.disconnect();}catch{}try{this.source.disconnect();}catch{}this.ctx.close();}};function L(){return URL.createObjectURL(new Blob([d],{type:"application/javascript"}))}
+export{w as a,y as b};

package/dist/index-BctoEDhZ.d.cts

@@ -0,0 +1,288 @@
+interface Conv2DWeights {
+    weights: ArrayLike<number>;
+    bias: ArrayLike<number>;
+}
+interface DepthwiseWeights {
+    weights: ArrayLike<number>;
+    bias: ArrayLike<number>;
+}
+interface DepthwiseSeparableWeights {
+    dw: DepthwiseWeights;
+    pw: Conv2DWeights;
+}
+interface MBConvWeights {
+    expand: Conv2DWeights;
+    dw: DepthwiseWeights;
+    proj: Conv2DWeights;
+}
+interface DecoderBlockWeights {
+    conv1: Conv2DWeights;
+    conv2: Conv2DWeights;
+}
+interface UNetWrapperWeights {
+    down1: Conv2DWeights;
+    down2?: Conv2DWeights;
+    adapter: Conv2DWeights;
+    expandFeat: Conv2DWeights;
+    up1Combine?: Conv2DWeights;
+    upCombine: Conv2DWeights;
+}
+interface FlowWeights {
+    stem: Conv2DWeights;
+    stages: Conv2DWeights[];
+    predictBot: Conv2DWeights;
+    deconv: Conv2DWeights[];
+    predict: Conv2DWeights[];
+}
+interface FaceWeights {
+    proj: Conv2DWeights;
+    block1: DecoderBlockWeights;
+    block2: DecoderBlockWeights;
+    out: Conv2DWeights;
+}
+interface LandmarkWeights {
+    stem: Conv2DWeights;
+    blocks: Conv2DWeights[];
+    headConv: Conv2DWeights;
+    fc: Conv2DWeights;
+}
+interface ModelWeights {
+    encoder: {
+        stem: Conv2DWeights;
+        s0: DepthwiseSeparableWeights;
+        s1: MBConvWeights[];
+        s2: MBConvWeights[];
+        s3: MBConvWeights[];
+        s4: MBConvWeights[];
+        s5?: MBConvWeights[];
+        s6?: MBConvWeights[];
+    };
+    bottleneck: Conv2DWeights;
+    decoder: {
+        blocks: DecoderBlockWeights[];
+        finalUpsample: Conv2DWeights;
+        outputConv: Conv2DWeights;
+    };
+}
+
+type Dtype = 'f32' | 'f16';
+interface Tensor {
+    readonly h: number;
+    readonly w: number;
+    readonly c: number;
+}
+interface MLBuffer {
+}
+interface Op {
+    readonly inputs: Tensor[];
+    readonly output: Tensor;
+    run(): void;
+}
+interface Presenter {
+    run(): void;
+}
+type RenderTarget = "main" | "preview";
+type Activation = "none" | "relu6" | "relu" | "leaky";
+interface Conv2dParams {
+    outChannels: number;
+    kernel: number;
+    stride: number;
+    padding: number | "same" | "valid";
+    activation: Activation;
+}
+interface DepthwiseParams {
+    kernel: number;
+    stride: number;
+    padding: number | "same" | "valid";
+    activation: Activation;
+}
+interface ConvTranspose2dParams {
+    outChannels: number;
+    kernel: number;
+    stride: number;
+    padding: number;
+    activation: Activation;
+}
+interface WarpParams {
+    flowScale: number;
+}
+interface StabilizeParams {
+    tLo: number;
+    tHi: number;
+    leak: number;
+    release: number;
+    tDiv: number;
+    divScale: number;
+    stepX: number;
+    stepY: number;
+}
+interface UpsampleParams {
+    outH: number;
+    outW: number;
+}
+interface FaceBoxParams {
+    win: number;
+    thresh: number;
+    boxScale: number;
+}
+interface FaceBoxesParams extends FaceBoxParams {
+    maxFaces: number;
+    tol: number;
+}
+interface CropResampleParams {
+    outH: number;
+    outW: number;
+    mean: [number, number, number];
+    std: [number, number, number];
+    slot?: number;
+}
+interface LandmarkOverlayParams {
+    count: number;
+    thresh: number;
+    pointSize: number;
+    color: [number, number, number];
+    slot?: number;
+    drawImage?: boolean;
+}
+interface ReframeStateParams {
+    zoom: number;
+    gravity: number;
+    margin: number;
+    deadband: number;
+    ease: number;
+    aspect: number;
+}
+interface FaceTouchupStageOp extends Op {
+    setActiveSlots(n: number): void;
+}
+interface FaceTopology {
+    count: number;
+    uv: Float32Array;
+    idx: Float32Array;
+    weightMask: ImageBitmap;
+}
+type FaceTouchupStyle = "freq-sep" | "bilateral";
+interface FaceTouchupParams {
+    strength: number;
+    amount: number;
+    detail: number;
+    thresh: number;
+    style?: FaceTouchupStyle;
+    slots?: number;
+}
+interface UpsampleConv1x1Params {
+    outH: number;
+    outW: number;
+    outChannels: number;
+    activation: Activation;
+}
+interface ProjResidualParams {
+    outChannels: number;
+}
+interface ConcatConv2dParams {
+    outChannels: number;
+}
+interface DownAdapterParams {
+    stride: number;
+}
+type ImageSource = ImageBitmap | VideoFrame;
+interface InputOp {
+    readonly output: Tensor;
+    setSource(src: ImageSource): void;
+    run(): void;
+}
+type DataView_ = Float32Array | Uint16Array;
+interface Backend {
+    readonly dtype: Dtype;
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    tensor(h: number, w: number, c: number, data?: DataView_): Tensor;
+    upload(data: DataView_): MLBuffer;
+    ops: {
+        Conv2d: (input: Tensor, weights: Conv2DWeights, params: Conv2dParams) => Op;
+        ConvTranspose2d: (input: Tensor, weights: Conv2DWeights, params: ConvTranspose2dParams) => Op;
+        DepthwiseConv2d: (input: Tensor, weights: DepthwiseWeights, params: DepthwiseParams) => Op;
+        Add: (a: Tensor, b: Tensor) => Op;
+        Sigmoid: (input: Tensor) => Op;
+        BilinearUpsample: (input: Tensor, params: UpsampleParams) => Op;
+        Crop: (input: Tensor, params: UpsampleParams) => Op;
+        BicubicUpsample: (input: Tensor, params: UpsampleParams) => Op;
+        ChannelConcat: (a: Tensor, b: Tensor) => Op;
+        Tanh: (input: Tensor) => Op;
+        ElementwiseMul: (a: Tensor, b: Tensor) => Op;
+        Warp: (source: Tensor, flow: Tensor, params: WarpParams) => Op;
+        FaceBoxFromHeatmaps: (heatmaps: Tensor, params: FaceBoxParams) => Op;
+        FaceBoxesFromHeatmaps: (heatmaps: Tensor, params: FaceBoxesParams) => Op;
+        ReframeState: (boxes: Tensor, prev: Tensor, cmd: Tensor, params: ReframeStateParams) => Op;
+        Reframe: (src: Tensor, rect: Tensor) => Op;
+        FaceTouchupStage: (frame: Tensor, landmarks: Tensor, box: Tensor, topo: FaceTopology, params: FaceTouchupParams) => FaceTouchupStageOp;
+        CropResample: (frame: Tensor, box: Tensor, params: CropResampleParams) => Op;
+        Stabilize: (flow: Tensor, pred: Tensor, ref: Tensor, envPrev: Tensor, params: StabilizeParams) => Op;
+        GatesFused: (uIn: Tensor, hPrev: Tensor, weights: Conv2DWeights) => Op;
+        CandUpdateFused: (uIn: Tensor, hPrev: Tensor, gatesOut: Tensor, weights: Conv2DWeights, gamma: ArrayLike<number>) => Op;
+        ConvExpand: (input: Tensor, weights: Conv2DWeights) => Op;
+        CatConv6to2: (u: Tensor, d: Tensor, weights: Conv2DWeights) => Op;
+        DownAdapter: (input: Tensor, downWeights: Conv2DWeights, adaptWeights: Conv2DWeights, params: DownAdapterParams) => Op;
+        UpFinal: (u: Tensor, rgb: Tensor, weights: Conv2DWeights) => Op;
+        UpFinalSkip: (u: Tensor, dFull: Tensor, rgb: Tensor, weights: Conv2DWeights) => Op;
+        Conv2dAdd: (input: Tensor, skip: Tensor, weights: Conv2DWeights, params: Conv2dParams) => Op;
+        ProjResidual: (input: Tensor, skip: Tensor, weights: Conv2DWeights, params: ProjResidualParams) => Op;
+        ConcatConv2d: (a: Tensor, b: Tensor, weights: Conv2DWeights, params: ConcatConv2dParams) => Op;
+        UpsampleConcat: (a: Tensor, b: Tensor, params: UpsampleParams) => Op;
+        UpsampleConv1x1: (input: Tensor, weights: Conv2DWeights, params: UpsampleConv1x1Params) => Op;
+        UpsampleSigmoid: (input: Tensor, params: UpsampleParams) => Op;
+        Input: (h: number, w: number) => InputOp;
+    };
+    presenters: {
+        CompositeSolid: (image: Tensor, alpha: Tensor, bgColor: [number, number, number], target?: RenderTarget) => Presenter;
+        CompositeImage: (image: Tensor, alpha: Tensor, bg: Tensor, target?: RenderTarget) => Presenter;
+        CompositeImageBilinear: (image: Tensor, alpha: Tensor, bg: Tensor, target?: RenderTarget) => Presenter;
+        CompositePassthrough: (image: Tensor, target?: RenderTarget) => Presenter;
+        LandmarkOverlay: (image: Tensor, landmarks: Tensor, box: Tensor, params: LandmarkOverlayParams, target?: RenderTarget) => Presenter;
+        FaceTouchup: (frame: Tensor, landmarks: Tensor, box: Tensor, topo: FaceTopology, params: FaceTouchupParams, target?: RenderTarget) => Presenter;
+    };
+    attachCanvas(name: RenderTarget, canvas: HTMLCanvasElement | OffscreenCanvas): void;
+    readback(tensor: Tensor): Promise<Float32Array>;
+    copyTensor(src: Tensor, dst: Tensor): void;
+    sync(): Promise<void>;
+    destroy(): void;
+}
+
+interface WebGPUTensor extends Tensor {
+    readonly buffer: GPUBuffer;
+}
+interface WebGPUMLBuffer extends MLBuffer {
+    readonly buffer: GPUBuffer;
+}
+
+interface WebGPUBackendOptions {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    device?: GPUDevice;
+    dtype?: Dtype;
+}
+declare class WebGPUBackend implements Backend {
+    readonly device: GPUDevice;
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    readonly dtype: Dtype;
+    readonly ops: Backend["ops"];
+    readonly presenters: Backend["presenters"];
+    readonly canvasContext: GPUCanvasContext;
+    readonly canvasFormat: GPUTextureFormat;
+    readonly bytesPerElement: 2 | 4;
+    private readonly contexts;
+    private constructor();
+    private configureContext;
+    attachCanvas(name: RenderTarget, canvas: HTMLCanvasElement | OffscreenCanvas): void;
+    static isAvailable(): Promise<boolean>;
+    static hasF16Support(): Promise<boolean>;
+    static create(opts: WebGPUBackendOptions): Promise<WebGPUBackend>;
+    getCurrentDisplayTexture(target?: RenderTarget): GPUTexture;
+    tensor(h: number, w: number, c: number, data?: DataView_): WebGPUTensor;
+    upload(data: DataView_): WebGPUMLBuffer;
+    private writeView;
+    readback(tensor: WebGPUTensor): Promise<Float32Array>;
+    copyTensor(src: WebGPUTensor, dst: WebGPUTensor): void;
+    sync(): Promise<void>;
+    destroy(): void;
+}
+
+export { type Activation as A, type Backend as B, type Conv2dParams as C, type Dtype as D, type FaceTouchupStyle as F, type InputOp as I, type LandmarkWeights as L, type MLBuffer as M, type Op as O, type Presenter as P, type RenderTarget as R, type Tensor as T, type UNetWrapperWeights as U, WebGPUBackend as W, type DepthwiseParams as a, type DataView_ as b, type ModelWeights as c, type ImageSource as d, type Conv2DWeights as e, type DecoderBlockWeights as f, type DepthwiseWeights as g, type FaceWeights as h, type FlowWeights as i, type MBConvWeights as j, type UpsampleParams as k };

package/dist/index-BctoEDhZ.d.ts

@@ -0,0 +1,288 @@
+interface Conv2DWeights {
+    weights: ArrayLike<number>;
+    bias: ArrayLike<number>;
+}
+interface DepthwiseWeights {
+    weights: ArrayLike<number>;
+    bias: ArrayLike<number>;
+}
+interface DepthwiseSeparableWeights {
+    dw: DepthwiseWeights;
+    pw: Conv2DWeights;
+}
+interface MBConvWeights {
+    expand: Conv2DWeights;
+    dw: DepthwiseWeights;
+    proj: Conv2DWeights;
+}
+interface DecoderBlockWeights {
+    conv1: Conv2DWeights;
+    conv2: Conv2DWeights;
+}
+interface UNetWrapperWeights {
+    down1: Conv2DWeights;
+    down2?: Conv2DWeights;
+    adapter: Conv2DWeights;
+    expandFeat: Conv2DWeights;
+    up1Combine?: Conv2DWeights;
+    upCombine: Conv2DWeights;
+}
+interface FlowWeights {
+    stem: Conv2DWeights;
+    stages: Conv2DWeights[];
+    predictBot: Conv2DWeights;
+    deconv: Conv2DWeights[];
+    predict: Conv2DWeights[];
+}
+interface FaceWeights {
+    proj: Conv2DWeights;
+    block1: DecoderBlockWeights;
+    block2: DecoderBlockWeights;
+    out: Conv2DWeights;
+}
+interface LandmarkWeights {
+    stem: Conv2DWeights;
+    blocks: Conv2DWeights[];
+    headConv: Conv2DWeights;
+    fc: Conv2DWeights;
+}
+interface ModelWeights {
+    encoder: {
+        stem: Conv2DWeights;
+        s0: DepthwiseSeparableWeights;
+        s1: MBConvWeights[];
+        s2: MBConvWeights[];
+        s3: MBConvWeights[];
+        s4: MBConvWeights[];
+        s5?: MBConvWeights[];
+        s6?: MBConvWeights[];
+    };
+    bottleneck: Conv2DWeights;
+    decoder: {
+        blocks: DecoderBlockWeights[];
+        finalUpsample: Conv2DWeights;
+        outputConv: Conv2DWeights;
+    };
+}
+
+type Dtype = 'f32' | 'f16';
+interface Tensor {
+    readonly h: number;
+    readonly w: number;
+    readonly c: number;
+}
+interface MLBuffer {
+}
+interface Op {
+    readonly inputs: Tensor[];
+    readonly output: Tensor;
+    run(): void;
+}
+interface Presenter {
+    run(): void;
+}
+type RenderTarget = "main" | "preview";
+type Activation = "none" | "relu6" | "relu" | "leaky";
+interface Conv2dParams {
+    outChannels: number;
+    kernel: number;
+    stride: number;
+    padding: number | "same" | "valid";
+    activation: Activation;
+}
+interface DepthwiseParams {
+    kernel: number;
+    stride: number;
+    padding: number | "same" | "valid";
+    activation: Activation;
+}
+interface ConvTranspose2dParams {
+    outChannels: number;
+    kernel: number;
+    stride: number;
+    padding: number;
+    activation: Activation;
+}
+interface WarpParams {
+    flowScale: number;
+}
+interface StabilizeParams {
+    tLo: number;
+    tHi: number;
+    leak: number;
+    release: number;
+    tDiv: number;
+    divScale: number;
+    stepX: number;
+    stepY: number;
+}
+interface UpsampleParams {
+    outH: number;
+    outW: number;
+}
+interface FaceBoxParams {
+    win: number;
+    thresh: number;
+    boxScale: number;
+}
+interface FaceBoxesParams extends FaceBoxParams {
+    maxFaces: number;
+    tol: number;
+}
+interface CropResampleParams {
+    outH: number;
+    outW: number;
+    mean: [number, number, number];
+    std: [number, number, number];
+    slot?: number;
+}
+interface LandmarkOverlayParams {
+    count: number;
+    thresh: number;
+    pointSize: number;
+    color: [number, number, number];
+    slot?: number;
+    drawImage?: boolean;
+}
+interface ReframeStateParams {
+    zoom: number;
+    gravity: number;
+    margin: number;
+    deadband: number;
+    ease: number;
+    aspect: number;
+}
+interface FaceTouchupStageOp extends Op {
+    setActiveSlots(n: number): void;
+}
+interface FaceTopology {
+    count: number;
+    uv: Float32Array;
+    idx: Float32Array;
+    weightMask: ImageBitmap;
+}
+type FaceTouchupStyle = "freq-sep" | "bilateral";
+interface FaceTouchupParams {
+    strength: number;
+    amount: number;
+    detail: number;
+    thresh: number;
+    style?: FaceTouchupStyle;
+    slots?: number;
+}
+interface UpsampleConv1x1Params {
+    outH: number;
+    outW: number;
+    outChannels: number;
+    activation: Activation;
+}
+interface ProjResidualParams {
+    outChannels: number;
+}
+interface ConcatConv2dParams {
+    outChannels: number;
+}
+interface DownAdapterParams {
+    stride: number;
+}
+type ImageSource = ImageBitmap | VideoFrame;
+interface InputOp {
+    readonly output: Tensor;
+    setSource(src: ImageSource): void;
+    run(): void;
+}
+type DataView_ = Float32Array | Uint16Array;
+interface Backend {
+    readonly dtype: Dtype;
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    tensor(h: number, w: number, c: number, data?: DataView_): Tensor;
+    upload(data: DataView_): MLBuffer;
+    ops: {
+        Conv2d: (input: Tensor, weights: Conv2DWeights, params: Conv2dParams) => Op;
+        ConvTranspose2d: (input: Tensor, weights: Conv2DWeights, params: ConvTranspose2dParams) => Op;
+        DepthwiseConv2d: (input: Tensor, weights: DepthwiseWeights, params: DepthwiseParams) => Op;
+        Add: (a: Tensor, b: Tensor) => Op;
+        Sigmoid: (input: Tensor) => Op;
+        BilinearUpsample: (input: Tensor, params: UpsampleParams) => Op;
+        Crop: (input: Tensor, params: UpsampleParams) => Op;
+        BicubicUpsample: (input: Tensor, params: UpsampleParams) => Op;
+        ChannelConcat: (a: Tensor, b: Tensor) => Op;
+        Tanh: (input: Tensor) => Op;
+        ElementwiseMul: (a: Tensor, b: Tensor) => Op;
+        Warp: (source: Tensor, flow: Tensor, params: WarpParams) => Op;
+        FaceBoxFromHeatmaps: (heatmaps: Tensor, params: FaceBoxParams) => Op;
+        FaceBoxesFromHeatmaps: (heatmaps: Tensor, params: FaceBoxesParams) => Op;
+        ReframeState: (boxes: Tensor, prev: Tensor, cmd: Tensor, params: ReframeStateParams) => Op;
+        Reframe: (src: Tensor, rect: Tensor) => Op;
+        FaceTouchupStage: (frame: Tensor, landmarks: Tensor, box: Tensor, topo: FaceTopology, params: FaceTouchupParams) => FaceTouchupStageOp;
+        CropResample: (frame: Tensor, box: Tensor, params: CropResampleParams) => Op;
+        Stabilize: (flow: Tensor, pred: Tensor, ref: Tensor, envPrev: Tensor, params: StabilizeParams) => Op;
+        GatesFused: (uIn: Tensor, hPrev: Tensor, weights: Conv2DWeights) => Op;
+        CandUpdateFused: (uIn: Tensor, hPrev: Tensor, gatesOut: Tensor, weights: Conv2DWeights, gamma: ArrayLike<number>) => Op;
+        ConvExpand: (input: Tensor, weights: Conv2DWeights) => Op;
+        CatConv6to2: (u: Tensor, d: Tensor, weights: Conv2DWeights) => Op;
+        DownAdapter: (input: Tensor, downWeights: Conv2DWeights, adaptWeights: Conv2DWeights, params: DownAdapterParams) => Op;
+        UpFinal: (u: Tensor, rgb: Tensor, weights: Conv2DWeights) => Op;
+        UpFinalSkip: (u: Tensor, dFull: Tensor, rgb: Tensor, weights: Conv2DWeights) => Op;
+        Conv2dAdd: (input: Tensor, skip: Tensor, weights: Conv2DWeights, params: Conv2dParams) => Op;
+        ProjResidual: (input: Tensor, skip: Tensor, weights: Conv2DWeights, params: ProjResidualParams) => Op;
+        ConcatConv2d: (a: Tensor, b: Tensor, weights: Conv2DWeights, params: ConcatConv2dParams) => Op;
+        UpsampleConcat: (a: Tensor, b: Tensor, params: UpsampleParams) => Op;
+        UpsampleConv1x1: (input: Tensor, weights: Conv2DWeights, params: UpsampleConv1x1Params) => Op;
+        UpsampleSigmoid: (input: Tensor, params: UpsampleParams) => Op;
+        Input: (h: number, w: number) => InputOp;
+    };
+    presenters: {
+        CompositeSolid: (image: Tensor, alpha: Tensor, bgColor: [number, number, number], target?: RenderTarget) => Presenter;
+        CompositeImage: (image: Tensor, alpha: Tensor, bg: Tensor, target?: RenderTarget) => Presenter;
+        CompositeImageBilinear: (image: Tensor, alpha: Tensor, bg: Tensor, target?: RenderTarget) => Presenter;
+        CompositePassthrough: (image: Tensor, target?: RenderTarget) => Presenter;
+        LandmarkOverlay: (image: Tensor, landmarks: Tensor, box: Tensor, params: LandmarkOverlayParams, target?: RenderTarget) => Presenter;
+        FaceTouchup: (frame: Tensor, landmarks: Tensor, box: Tensor, topo: FaceTopology, params: FaceTouchupParams, target?: RenderTarget) => Presenter;
+    };
+    attachCanvas(name: RenderTarget, canvas: HTMLCanvasElement | OffscreenCanvas): void;
+    readback(tensor: Tensor): Promise<Float32Array>;
+    copyTensor(src: Tensor, dst: Tensor): void;
+    sync(): Promise<void>;
+    destroy(): void;
+}
+
+interface WebGPUTensor extends Tensor {
+    readonly buffer: GPUBuffer;
+}
+interface WebGPUMLBuffer extends MLBuffer {
+    readonly buffer: GPUBuffer;
+}
+
+interface WebGPUBackendOptions {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    device?: GPUDevice;
+    dtype?: Dtype;
+}
+declare class WebGPUBackend implements Backend {
+    readonly device: GPUDevice;
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    readonly dtype: Dtype;
+    readonly ops: Backend["ops"];
+    readonly presenters: Backend["presenters"];
+    readonly canvasContext: GPUCanvasContext;
+    readonly canvasFormat: GPUTextureFormat;
+    readonly bytesPerElement: 2 | 4;
+    private readonly contexts;
+    private constructor();
+    private configureContext;
+    attachCanvas(name: RenderTarget, canvas: HTMLCanvasElement | OffscreenCanvas): void;
+    static isAvailable(): Promise<boolean>;
+    static hasF16Support(): Promise<boolean>;
+    static create(opts: WebGPUBackendOptions): Promise<WebGPUBackend>;
+    getCurrentDisplayTexture(target?: RenderTarget): GPUTexture;
+    tensor(h: number, w: number, c: number, data?: DataView_): WebGPUTensor;
+    upload(data: DataView_): WebGPUMLBuffer;
+    private writeView;
+    readback(tensor: WebGPUTensor): Promise<Float32Array>;
+    copyTensor(src: WebGPUTensor, dst: WebGPUTensor): void;
+    sync(): Promise<void>;
+    destroy(): void;
+}
+
+export { type Activation as A, type Backend as B, type Conv2dParams as C, type Dtype as D, type FaceTouchupStyle as F, type InputOp as I, type LandmarkWeights as L, type MLBuffer as M, type Op as O, type Presenter as P, type RenderTarget as R, type Tensor as T, type UNetWrapperWeights as U, WebGPUBackend as W, type DepthwiseParams as a, type DataView_ as b, type ModelWeights as c, type ImageSource as d, type Conv2DWeights as e, type DecoderBlockWeights as f, type DepthwiseWeights as g, type FaceWeights as h, type FlowWeights as i, type MBConvWeights as j, type UpsampleParams as k };