@hraness/slopcamera 3.2.4

package/apps/desktop/html-overlay/spark-runtime.ts

@@ -0,0 +1,88 @@
+/** Exact, profile-scoped extension. Never change the historical runtime source. */
+const legacyObjectUrls = `  if (typeof globalThis.URL?.createObjectURL === "function") {
+    const rejectObjectUrl = () => {
+      throw new DOMException(
+        "Blob object URLs are unavailable; declare the overlay asset with SlopcameraOverlay.asset().",
+        "NotSupportedError",
+      );
+    };
+    replaceRuntimeValue(
+      globalThis.URL,
+      "createObjectURL",
+      rejectObjectUrl,
+    );
+    replaceRuntimeValue(
+      globalThis.URL,
+      "revokeObjectURL",
+      rejectObjectUrl,
+    );
+  }`;
+
+const boundedSparkWorkers = `  let sparkWorkerFailure = null;
+  {
+    const NativeWorker = globalThis.Worker;
+    const nativeCreateUrl = globalThis.URL.createObjectURL.bind(globalThis.URL);
+    const nativeRevokeUrl = globalThis.URL.revokeObjectURL.bind(globalThis.URL);
+    const nativeTerminate = NativeWorker.prototype.terminate;
+    const nativeAddListener = EventTarget.prototype.addEventListener;
+    const apply = Reflect.apply;
+    const nativeBlobSize = Object.getOwnPropertyDescriptor(Blob.prototype, "size").get;
+    const nativeBlobType = Object.getOwnPropertyDescriptor(Blob.prototype, "type").get;
+    const urls = new Map();
+    const workers = new Set();
+    let liveBytes = 0, createdUrls = 0, createdWorkers = 0;
+    const revoke = (url) => {
+      if (typeof url !== "string") throw new TypeError("Spark worker URL must be a string.");
+      const bytes = urls.get(url);
+      if (bytes !== undefined) { liveBytes -= bytes; urls.delete(url); nativeRevokeUrl(url); }
+    };
+    replaceRuntimeValue(globalThis.URL, "createObjectURL", (blob) => {
+      const size = apply(nativeBlobSize, blob, []), type = apply(nativeBlobType, blob, []);
+      if (!["application/javascript", "text/javascript", "text/javascript;charset=utf-8"].includes(type)
+        || size < 1 || size > 8388608 || urls.size >= 8 || createdUrls >= 128
+        || liveBytes + size > 33554432) throw new RangeError("Spark worker Blob exceeds the closed script or lifecycle budget.");
+      const url = nativeCreateUrl(blob);
+      urls.set(url, size); liveBytes += size; createdUrls++;
+      return url;
+    });
+    replaceRuntimeValue(globalThis.URL, "revokeObjectURL", revoke);
+    function SlopcameraSparkWorker(url, options) {
+      if (!new.target) throw new TypeError("Spark Worker requires construction.");
+      const name = options?.name, type = options?.type;
+      if (typeof url !== "string" || !urls.has(url) || workers.size >= 4 || createdWorkers >= 64
+        || (options !== undefined && (options === null || typeof options !== "object"
+          || Object.keys(options).some(key => key !== "name" && key !== "type")
+          || (type !== undefined && type !== "classic")
+          || (name !== undefined && (typeof name !== "string" || name.length > 128))))) {
+        throw new RangeError("Spark requires bounded owned Blob workers with classic scripts.");
+      }
+      const worker = new NativeWorker(url, { type: "classic", ...(name === undefined ? {} : { name }) });
+      workers.add(worker); createdWorkers++;
+      const terminate = () => { workers.delete(worker); apply(nativeTerminate, worker, []); };
+      Object.defineProperty(worker, "terminate", { configurable: false, writable: false, value: terminate });
+      apply(nativeAddListener, worker, ["error", () => { sparkWorkerFailure = new Error("Spark worker failed."); }]);
+      apply(nativeAddListener, worker, ["messageerror", () => { sparkWorkerFailure = new Error("Spark worker message failed."); }]);
+      return worker;
+    }
+    Object.defineProperty(SlopcameraSparkWorker, "prototype", { value: NativeWorker.prototype, writable: false });
+    Object.defineProperty(NativeWorker.prototype, "constructor", { configurable: false, writable: false, value: SlopcameraSparkWorker });
+    replaceRuntimeValue(globalThis, "Worker", SlopcameraSparkWorker);
+    replaceRuntimeValue(globalThis, "SharedWorker", function () { throw new Error("Shared workers are unavailable in a spatial render."); });
+    apply(nativeAddListener, globalThis, ["pagehide", () => {
+      for (const worker of workers) apply(nativeTerminate, worker, []);
+      workers.clear();
+      for (const url of urls.keys()) nativeRevokeUrl(url);
+      urls.clear(); liveBytes = 0;
+    }, { once: true }]);
+  }`;
+
+function replaceExactlyOnce(source: string, target: string, replacement: string): string {
+  const offset = source.indexOf(target);
+  if (offset < 0 || source.indexOf(target, offset + target.length) !== -1) throw new Error("Spark runtime extension requires one exact historical runtime seam.");
+  return source.slice(0, offset) + replacement + source.slice(offset + target.length);
+}
+
+export function createSparkHtmlOverlayRuntimeSource(legacySource: string): string {
+  const source = replaceExactlyOnce(legacySource, legacyObjectUrls, boundedSparkWorkers);
+  return replaceExactlyOnce(source, "return securityViolations;", "return securityViolations + (sparkWorkerFailure === null ? 0 : 1);");
+}

package/apps/desktop/html-overlay/spatial-splat-runtime.ts

@@ -0,0 +1,60 @@
+/** Only the explicit Spark profile receives these additions. The legacy generated document stays byte-identical. */
+export function addSpatialSplatRuntime(document: string): string {
+  const replace = (source: string, replacement: string) => {
+    if (document.split(source).length !== 2) throw new Error("Spatial Spark runtime anchor changed; review the pinned renderer adapter.");
+    document = document.replace(source, replacement);
+  };
+  replace('import * as THREE from "three";', 'import * as THREE from "three";\nimport { SparkRenderer, SplatMesh } from "@sparkjsdev/spark";');
+  replace('SlopcameraOverlay.ready(initialization);', `
+// Exact offline readback avoids Three's wall-clock fence polling under the
+// absolute Slopcamera frame clock. Both APIs bind the same target and MRT attachment.
+renderer.readRenderTargetPixelsAsync=async(target,x,y,width,height,buffer,face,attachment)=>{
+  const texture=target.textures?.[attachment],gl=renderer.getContext();
+  if(attachment!==2||texture?.format!==THREE.RGBAFormat||texture?.type!==THREE.UnsignedByteType||buffer.BYTES_PER_ELEMENT!==1||buffer.byteLength<width*height*4||x<0||y<0||x+width>target.width||y+height>target.height)throw new Error("Spark requested an unqualified MRT readback.");
+  if(gl.getError()!==gl.NO_ERROR)throw new Error("Spark GPU failed before readback.");
+  renderer.readRenderTargetPixels(target,x,y,width,height,buffer,face,attachment);
+  if(gl.getError()!==gl.NO_ERROR||gl.isContextLost())throw new Error("Spark GPU readback failed.");return buffer;
+};
+const spark=new SparkRenderer({renderer,autoUpdate:false,preUpdate:false,enableLod:false,enableDriveLod:false,enableLodFetching:false,
+  maxPagedSplats:65536,numLodFetchers:0,lodRaycast:0,accumExtSplats:true,premultipliedAlpha:true,encodeLinear:true,sortRadial:false,minSortIntervalMs:0,depthTest:true,depthWrite:false,
+  preBlurAmount:input.splatKernel.preBlurAmount,blurAmount:input.splatKernel.blurAmount});
+spark.readPause=0;spark.sortPause=0;spark.sortDelay=0;
+const splatMeshes=new Map();
+const disposeSplats=()=>{for(const mesh of splatMeshes.values())mesh.dispose();splatMeshes.clear();spark.dispose();};
+const splatInitialization=initialization.then(async()=>{
+  const gl=renderer.getContext();
+  if(gl.getParameter(gl.MAX_TEXTURE_SIZE)<4096||gl.getParameter(gl.MAX_ARRAY_TEXTURE_LAYERS)<1||gl.getParameter(gl.MAX_DRAW_BUFFERS)<3)throw new Error("Spark GPU allocation capabilities are unavailable.");
+  for(const item of input.splats){
+    const response=await fetch(item.url);if(!response.ok)throw new Error("Retained SPZ resource is unavailable.");
+    const bytes=await response.arrayBuffer();
+    if(bytes.byteLength!==item.resource.bytes)throw new Error("Retained SPZ resource length changed.");
+    const hash=new Uint8Array(await crypto.subtle.digest("SHA-256",bytes));
+    const sha256=Array.from(hash,value=>value.toString(16).padStart(2,"0")).join("");
+    if(sha256!==item.resource.sha256)throw new Error("Retained SPZ resource digest changed.");
+    const mesh=new SplatMesh({fileBytes:bytes,fileType:"spz",extSplats:true,maxSplats:item.facts.splats,lod:false,enableLod:false,editable:false,raycastable:false});
+    splatMeshes.set(item.key,mesh);await mesh.initialized;
+    if(disposed)throw new Error("Spatial renderer was disposed during splat preparation.");
+    if(mesh.extSplats?.numSplats!==item.facts.splats)throw new Error("Spark decoded a different splat count from the admitted source.");
+    mesh.matrixAutoUpdate=false;mesh.frustumCulled=false;
+  }
+}).catch(error=>{disposeSplats();throw error;});
+SlopcameraOverlay.ready(splatInitialization);`);
+  replace('SlopcameraOverlay.onFrame(({frame:index})=>{', 'SlopcameraOverlay.onFrame(async({frame:index})=>{');
+  replace('camera.updateMatrixWorld(true);return camera;', 'camera.near=data.near;camera.far=data.far;camera.updateMatrixWorld(true);return camera;');
+  replace('    for(const object of frame.objects){', `    const hasFrameSplats=frame.objects.some(object=>object.kind==="splat");spark.visible=hasFrameSplats;world.add(spark);
+    for(const object of frame.objects){
+      if(object.kind==="splat"){
+        const mesh=splatMeshes.get(object.key);if(!mesh)throw new Error("Splat frame binding is absent.");
+        mesh.matrix.fromArray(object.matrix);world.add(mesh);continue;
+      }`);
+  replace('    renderer.setRenderTarget(beautyTarget);renderer.clear(true,true,true);renderer.render(world,camera);', `    if(spark.sorting||spark.sortDirty||spark.sortTimeoutId!==-1||spark.updateTimeoutId!==-1)throw new Error("A previous Spark view did not settle.");
+    // Explicit offline samples may seek backwards; never apply a wall-clock throttle.
+    spark.lastSortTime=0;
+    spark.time=frame.timeUs/1000000;spark.renderSize.set(SlopcameraOverlay.width,SlopcameraOverlay.height);
+    world.updateMatrixWorld(true);if(hasFrameSplats)await spark.update({scene:world,camera});
+    if(spark.sorting||spark.sortDirty||(hasFrameSplats&&spark.display!==spark.current))throw new Error("Spark did not settle the exact directed camera sample.");
+    if(contextFailure||disposed)throw contextFailure??new Error("Spatial renderer was disposed while sorting.");
+    renderer.setRenderTarget(beautyTarget);renderer.clear(true,true,true);renderer.render(world,camera);`);
+  replace('addEventListener("pagehide",()=>{disposed=true;', 'addEventListener("pagehide",()=>{disposeSplats();disposed=true;');
+  return document;
+}