allyhub 0.7.0 → 0.8.0

package/dist/node_modules/@allyhub/scenery-host/dist/layer/queries.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{PANEL_DEFAULTS as N}from"@allyhub/scenery";import{layerFacts as A}from"../measure/facts.js";import{sceneryFileOf as d}from"../module.js";import{layerFidelity as E}from"./fidelity.js";import{cameraOf as g,named as T,sceneryAtFilm as l,windowOf as w}from"./state.js";function L(e,n,s){return n.screens.drawsElements&&s.spec.inScenery!==!1?{in:"scenery",scale:Math.round(e.canvas.width/e.px.w*1e4)/1e4}:{in:"over",scale:1}}function k(e){let n;const s=document.createTreeWalker(e,NodeFilter.SHOW_TEXT);for(let t=s.nextNode();t;t=s.nextNode()){if(!t.textContent?.trim())continue;const r=t.parentElement;if(!r)continue;const o=parseFloat(getComputedStyle(r).fontSize);Number.isFinite(o)&&o>0&&(n===void 0||o<n)&&(n=o)}return n===void 0?void 0:Math.round(n*100)/100}export async function factsOf(e){const n=e.page;if(!n)return[];const s=w(e);if(!s)return[];const t=e.props.name,{from:r,to:o,part:a,partStart:c,speed:p,toOuter:f}=s,u=f(r)-c,O=f(o)-c,y=l(e.props,r),h=l(e.props,o),[S,F]=y<=h?[y,h]:[h,y],M=i=>i.filter(m=>m.to>S+1e-9&&m.from<F-1e-9),x=d(e.props.scenery),b=await T(t,a,()=>A(n,{layer:t,start:u,end:O,sceneryAt:i=>l(e.props,r+i*p),camera:g(e),time:e.time,aspect:e.px.w/e.px.h,frame:[e.px.w,e.px.h],box:[e.px.x,e.px.y,e.px.w,e.px.h],scenery:e.ctx.embedded!==!0,...x===void 0?{}:{file:x},...e.props.sensor?{sensor:e.props.sensor,output:[e.ctx.dims.width,e.ctx.dims.height]}:{},screens:e.screens.map(i=>{const m=k(i.el);return{mesh:i.mesh,size:i.size,...i.spec.pixels?{pixels:i.spec.pixels}:{},...i.stretches?{stretches:M(i.stretches)}:{},...m===void 0?{}:{text:m},drawn:L(e,n,i)}})})),z=Math.round((c+u)*1e6)/1e6;return b.map(i=>({...i,...a===void 0?{}:{part:a},t:z}))}export function cutsOfLayer(e,n){const s=[];if(!e.page)return s;const t=w(e);if(!t)return s;const r=e.props.name,o=Math.ceil(t.from*n-1e-6),a=Math.ceil(t.to*n-1e-6);for(const c of e.page.cutsOf(g(e),e.time))for(let p=o;p<a;p++)if(!(l(e.props,p/n)<c-1e-9)){if(p>o){const f=Math.round(t.toOuter(p/n)*1e6)/1e6;s.some(u=>u.t===f)||s.push({layer:r,...t.part===void 0?{}:{part:t.part},t:f})}break}return s.sort((c,p)=>c.t-p.t)}export function timesOfLayer(e,n){const s={},t={};for(const a of n)try{const c=e.time(a);Number.isFinite(c)?s[a]=Math.round(c*1e6)/1e6:t[a]=`no time (${String(c)})`}catch(c){t[a]=c.message}const r=d(e.props.scenery),o=e.ctx.film?.part;return{layer:e.props.name,...o===void 0?{}:{part:o},...r===void 0?{}:{file:r},times:s,missing:t}}export function answerFor(e){const n=e.ctx.answer?.bind(e.ctx);if(!n)return;n("scenery.facts",()=>factsOf(e)),n("scenery.cuts",({fps:t})=>cutsOfLayer(e,t)),n("scenery.times",({refs:t})=>timesOfLayer(e,t));const s=E(()=>{const t=w(e);if(!(!e.page||!t))return{name:e.props.name,page:e.page,from:t.toOuter(t.from),to:t.toOuter(t.to),...t.part===void 0?{}:{part:t.part},partStart:t.partStart,screens:e.screens.map(r=>({mesh:r.mesh,el:r.el,surface:r.surface,size:r.size,inScenery:r.spec.inScenery!==!1,density:r.spec.pixels?.density??N.density}))}});n("scenery.fidelity",({times:t,every:r})=>s.moments(t,r)),n("scenery.fidelity.read",({id:t,mesh:r,most:o})=>s.read(t,r,o)),n("scenery.fidelity.lift",({id:t,mesh:r,backdrop:o})=>s.lift(t,r,o)),n("scenery.fidelity.restore",()=>(s.restore(),null))}

package/dist/node_modules/@allyhub/scenery-host/dist/layer/screens.d.ts

@@ -0,0 +1,58 @@
+import { type Px, type ResolvedCamera, type ScreenFocus } from "@allyhub/scenery";
+import { type StageContext } from "@allyhub/video-core";
+import { type Drawn, type MountedScreen } from "./state.js";
+import type { Screen } from "./types.js";
+/**
+ * A screen's depth of field as an SVG filter on its element, in the
+ * holder beside it: the camera's blur at each point of the screen, which
+ * grows with its distance from the focus (@allyhub/scenery's screenFocus),
+ * mixed from a few Gaussian levels by a gradient across the content. A
+ * blur reaches no further than the screen's edge and fades nothing there:
+ * each level is made opaque again (its colour divided by its alpha), then
+ * cut to the content's own alpha. The filter's markup is rewritten only
+ * when it changes.
+ */
+export declare function blurScreen(sc: MountedScreen, focus: ScreenFocus | undefined): void;
+/** How a camera with an aperture blurs a screen of a scenery layer, at this moment. */
+export declare function screenFocusOf(d: Drawn, sc: MountedScreen, quad: {
+    corners: [Px, Px, Px, Px];
+} | undefined, camera: ResolvedCamera): ScreenFocus | undefined;
+/** A screen's elements and its layers mounted, under the scenery layer's canvas. */
+export declare function mountScreen(parent: HTMLElement, mesh: string, spec: Screen, outer: StageContext, toScenery: (partT: number) => number, refScenery: (ref: string) => number): MountedScreen;
+/** Screens' elements stacked farthest first, by the depth of their farthest corner. */
+export declare function stackByDepth(screens: readonly {
+    el: HTMLElement;
+    depth: number | undefined;
+}[]): void;
+/**
+ * A screen drawn in the scenery, at its panel's density and placed on the
+ * frame where its mesh shows it. Its element is laid out `density` times
+ * its content's size, the content scaled up inside it, so its picture has
+ * the panel's pixels. Its texture does not follow the element's own
+ * transform (HTML-in-Canvas draws an element before its CSS transforms),
+ * but its layout does: whatever measures the screen's elements (a callout,
+ * the layout facts) finds them where they are on the frame. The map from
+ * its content to the frame takes the element's pixels, so its input is
+ * divided by the density.
+ */
+export declare function placeInScenery(sc: MountedScreen, quad: {
+    corners: [Px, Px, Px, Px];
+    angle: number;
+} | undefined, density: number): void;
+/** A screen's content at scenery time t, without placing it: a screen drawn in the scenery. */
+export declare function screenTo(sc: MountedScreen, sceneryT: number): Promise<unknown>;
+/** A screen at scenery time: its content drawn, its picture mapped onto its quad. */
+export declare function drawScreen(sc: MountedScreen, sceneryT: number, quad: {
+    corners: [Px, Px, Px, Px];
+    angle: number;
+} | undefined): void;
+/**
+ * A screen's background reaching a band past its content's edge (frame
+ * px), under the canvas: where the hole's edge, stepped and soft, opens
+ * past the content, the screen's own background shows (black, as a
+ * screen's border is), not what lies under the scenery's picture.
+ */
+export declare function screenEdge(sc: MountedScreen, quad: {
+    corners: [Px, Px, Px, Px];
+} | undefined, band: number): void;
+//# sourceMappingURL=screens.d.ts.map

package/dist/node_modules/@allyhub/scenery-host/dist/layer/screens.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{homography as I,matrix3d as N,screenFocus as L,SCENERY_RENDERER_DEFAULTS as B}from"@allyhub/scenery";import{addLayerRule as U,layerShown as _,showLayer as j}from"@allyhub/video-core";import{coded as H}from"./state.js";export function blurScreen(t,r){if(!r){t.focus&&(t.surface.style.filter="");return}const e=t.el.parentElement;if(!e)return;if(!t.focus){const o=document.createElementNS(P,"svg");o.setAttribute("width","0"),o.setAttribute("height","0"),o.setAttribute("aria-hidden","true"),Object.assign(o.style,{position:"absolute",left:"0",top:"0"}),e.appendChild(o),D+=1,t.focus={svg:o,id:`ak-screen-focus-${String(D)}`,markup:""}}const n=V(t.focus.id,t.size,r);n!==t.focus.markup&&(t.focus.svg.innerHTML=n,t.focus.markup=n),t.surface.style.filter=`url(#${t.focus.id})`}const P="http://www.w3.org/2000/svg";let D=0;const b=t=>{const r=Math.round(t*1e3)/1e3;return String(Object.is(r,-0)?0:r)};function V(t,r,e){const[n,o]=r,i=[],c=e.sigmas.length>1;c&&i.push(`<defs><linearGradient id="${t}-lg" gradientUnits="userSpaceOnUse" x1="${b(e.from[0])}" y1="${b(e.from[1])}" x2="${b(e.to[0])}" y2="${b(e.to[1])}"><stop offset="0" stop-color="#000"/><stop offset="1" stop-color="#fff"/></linearGradient>`,`<rect id="${t}-r" x="0" y="0" width="${b(n)}" height="${b(o)}" fill="url(#${t}-lg)"/></defs>`),i.push(`<filter id="${t}" x="0" y="0" width="1" height="1" color-interpolation-filters="sRGB">`),c&&i.push(`<feImage href="#${t}-r" result="g"/>`,'<feColorMatrix in="g" type="matrix" values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0" result="w"/>');const f=[];e.sigmas.forEach((g,h)=>{const $=e.weights[h]??[];if(c&&!$.some(S=>S>0))return;const w=c?W(e,$,n,o):void 0,p=w?` x="${b(w[0])}" y="${b(w[1])}" width="${b(w[2])}" height="${b(w[3])}"`:"";let y="SourceGraphic";if(g>=.05&&(i.push(`<feGaussianBlur in="SourceGraphic" stdDeviation="${b(g)}"${p} result="b${String(h)}"/>`),y=`b${String(h)}`),!c){f.push(y);return}i.push(`<feComponentTransfer in="w"${p} result="w${String(h)}"><feFuncA type="table" tableValues="${$.map(b).join(" ")}"/></feComponentTransfer>`,`<feComposite in="${y}" in2="w${String(h)}" operator="arithmetic" k1="1"${p} result="m${String(h)}"/>`),f.push(`m${String(h)}`)});let d=f[0]??"SourceGraphic";return f.slice(1).forEach((g,h)=>{const $=`s${String(h)}`;i.push(`<feComposite in="${d}" in2="${g}" operator="arithmetic" k2="1" k3="1" result="${$}"/>`),d=$}),i.push(`<feColorMatrix in="${d}" type="matrix" values="1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1" result="o"/>`,'<feComposite in="o" in2="SourceAlpha" operator="in"/>',"</filter>"),i.join("")}function W(t,r,e,n){const o=r.length,i=r.findIndex(m=>m>0);let c=o-1;for(;c>0&&!((r[c]??0)>0);)c-=1;const f=Math.max(0,i-1)/(o-1),d=Math.min(o-1,c+1)/(o-1);if(f<=0&&d>=1)return;const g=t.to[0]-t.from[0],h=t.to[1]-t.from[1],$=g*g+h*h;if($<=0)return;const w=m=>((m[0]-t.from[0])*g+(m[1]-t.from[1])*h)/$,p=(m,C)=>{const s=[];return m.forEach((u,a)=>{const l=m[(a+1)%m.length]??u,x=C(u),v=C(l);if(x>=0&&s.push(u),x>=0!=v>=0){const M=x/(x-v);s.push([u[0]+(l[0]-u[0])*M,u[1]+(l[1]-u[1])*M])}}),s};let y=[[0,0],[e,0],[e,n],[0,n]];if(y=p(y,m=>w(m)-f),y=p(y,m=>d-w(m)),y.length===0)return[0,0,0,0];const S=y.map(m=>m[0]),E=y.map(m=>m[1]),O=Math.max(0,Math.floor(Math.min(...S))-1),z=Math.max(0,Math.floor(Math.min(...E))-1),A=Math.min(e,Math.ceil(Math.max(...S))+1),F=Math.min(n,Math.ceil(Math.max(...E))+1);return[O,z,A-O,F-z]}export function screenFocusOf(t,r,e,n){if(!n.dof||!e||!t.page)return;const o=t.page.screens.face(r.mesh);if(!o)return;const i=t.props.scenery.renderer?.focus?.maxRadius??B.focus.maxRadius,c=t.canvas.height/t.px.h;return L({camera:n,corners:[o.point(0,0),o.point(1,0),o.point(1,1),o.point(0,1)],quad:e.corners,size:r.size,frameHeight:t.px.h,levels:t.props.focusLevels,most:2*i/c})}export function mountScreen(t,r,e,n,o,i){const c=document.createElement("div");c.dataset.akScreen=r;const f=([s,u])=>{c.style.width=`${String(s)}px`,c.style.height=`${String(u)}px`};Object.assign(c.style,{position:"absolute",left:"0px",top:"0px",overflow:"hidden",transformOrigin:"0 0",opacity:"0.999",display:"none"});const d=document.createElement("div");Object.assign(d.style,{position:"absolute",inset:"0",background:e.background??"transparent"}),c.appendChild(d),f(e.size),t.appendChild(c);const g=e.time,h=e.start===void 0?void 0:typeof e.start=="number"?e.start:i(e.start),$=h!==void 0||e.cue!==void 0||e.cues!==void 0;let w=(typeof e.cue=="number"?e.cue:0)-(h??0),p;const y=s=>{if(!e.cues)return;const u=Object.entries(e.cues).map(([a,l])=>[typeof l=="number"?l:i(l),s(a.trim())]);u.sort((a,l)=>a[0]-l[0]);for(let a=1;a<u.length;a++){const[l,x]=u[a-1]??[0,0],[v,M]=u[a]??[0,0];if(!(v>l&&M>x))throw new Error(`screen() on "${r}": its cues are not in the same order on both clocks (the screen's ${x.toFixed(3)} s at scenery ${l.toFixed(3)} s, then ${M.toFixed(3)} s at ${v.toFixed(3)} s). Each later moment of the screen plays later.`)}p=u,E.stretches=u.slice(1).map((a,l)=>{const x=u[l]??a;return{from:x[0],to:a[0],video:[x[1],a[1]],speed:Math.round((a[1]-x[1])/(a[0]-x[0])*1e4)/1e4}})},S=s=>{if(p&&p.length>0){const u=p[0]??[0,0];if(s<=u[0])return u[1]+(s-u[0]);for(let l=1;l<p.length;l++){const[x,v]=p[l]??[0,0];if(s<=x){const[M,k]=p[l-1]??[0,0];return k+(s-M)/(x-M)*(v-k)}}const a=p[p.length-1]??[0,0];return a[1]+(s-a[0])}return $?w+s:typeof g=="function"?g(s):(g.from??0)+s},E={mesh:r,spec:e,el:c,surface:d,size:[e.size[0],e.size[1]],timeAt:S,ctx:n,layers:[]};if(e.video){if(!n.video)throw new Error(`This host cannot show a video on the screen "${r}".`);const s=document.createElement("div");return d.appendChild(s),n.wait(n.video(e.video,s).then(u=>{typeof e.cue=="string"&&(w=u.at(e.cue)-(h??0)),y(a=>a.startsWith("@")?u.at(a):Number(a)),E.video=u,E.size=[u.width,u.height],f(E.size)})),E}y(s=>Number(s));const[O,z]=e.size,A=e.dur??(!$&&typeof g=="function"?1/0:S(o(n.layer.end))),F=[0,0,O,z],m=s=>{if(!$&&typeof g=="function")throw new Error(`screen() on "${r}" has a function for its time, which a reference cannot be placed in: give it a start (or { from }) to time its layers by the script.`);return S(o(s))},C=s=>typeof s=="number"?s:m(n.at(s));return E.layers=T(c,()=>e.layers.map((s,u)=>{const a=document.createElement("div");Object.assign(a.style,{position:"absolute",inset:"0"}),j(a,!1),d.appendChild(a);const l=s.at===void 0?0:C(s.at),x=s.until!==void 0?C(s.until):s.dur!==void 0?l+s.dur:A,v={...n,get layoutOnly(){return n.layoutOnly===!0},format:`${O}x${z}`,dims:{width:O,height:z,orient:O>z?"landscape":O<z?"portrait":"square",safe:{top:0,bottom:0,left:0,right:0}},dur:A,words:()=>!$&&typeof g=="function"?[]:n.words().map(k=>({...k,start:m(k.start),end:m(k.end)})),at:C,layer:{start:l,end:x},captions:()=>[],face:()=>{},faces:()=>[],texts:()=>[],covered:[],content:F},M=s.times?R(s.props,s.times,C):s.props;return U(a.ownerDocument),j(a,!0),G(r,s,u,"mount",()=>{s.mount(a,M,v)}),j(a,!1),{spec:s,props:M,el:a,ctx:v,start:l,end:x}})),E}function T(t,r){const e=_(t);j(t,!0);try{return r()}finally{j(t,e)}}function R(t,r,e){if(Array.isArray(t))return t.map(o=>R(o,r,e));if(r===!0)return typeof t=="string"||typeof t=="number"?e(t):t;if(typeof t!="object"||t===null)return t;const n={...t};for(const[o,i]of Object.entries(r))o in n&&n[o]!==void 0&&(n[o]=R(n[o],i,e));return n}export function stackByDepth(t){t.map((e,n)=>({i:n,depth:e.depth??1/0})).sort((e,n)=>n.depth-e.depth||e.i-n.i).forEach(({i:e},n)=>{const o=t[e];o&&(o.el.style.zIndex=String(n))})}export function placeInScenery(t,r,e){const[n,o]=t.size;Object.assign(t.el.style,{display:"block",opacity:"1",width:`${String(n*e)}px`,height:`${String(o*e)}px`}),Object.assign(t.surface.style,{inset:"auto",left:"0px",top:"0px",width:`${String(n)}px`,height:`${String(o)}px`,transformOrigin:"0 0",transform:e===1?"none":`scale(${String(e)})`});const i=r?I(n,o,r.corners):void 0;if(!r||!i||r.angle>=90){t.el.style.transform="scale(0)";return}const c=i.map((f,d)=>d%3===2?f:f/e);t.el.style.transform=N(c.map(f=>Math.round(f*1e9)/1e9))}function G(t,r,e,n,o){try{o()}catch(i){throw H(i,`On the screen "${t}", its layer ${String(e+1)} (${r.component}) failed in ${n}: `)}}export function screenTo(t,r){const e=t.timeAt(r);if(t.video){const n=Math.max(0,t.video.duration-.001),o=Math.min(Math.max(e,0),n);return t.video.seek(o,t.ctx.layoutOnly===!0)}return t.layers.forEach((n,o)=>{const i=e>=n.start&&e<n.end;j(n.el,i),i&&G(t.mesh,n.spec,o,`render at ${e.toFixed(2)} s`,()=>{n.spec.render(n.el,e,n.props,n.ctx)})}),Promise.resolve()}export function drawScreen(t,r,e){const n=e?I(t.size[0],t.size[1],e.corners):void 0;if(!e||!n||e.angle>=90){t.el.style.display="none";return}t.el.style.display="block",t.el.style.transform=N(n.map(i=>Math.round(i*1e9)/1e9));const o=t.timeAt(r);if(t.video){const i=Math.max(0,t.video.duration-.001),c=t.video,f=Math.min(Math.max(o,0),i),d=t.ctx.layoutOnly===!0;t.ctx.wait(Promise.resolve().then(()=>c.seek(f,d)));return}t.layers.forEach((i,c)=>{const f=o>=i.start&&o<i.end;j(i.el,f),f&&G(t.mesh,i.spec,c,`render at ${o.toFixed(2)} s`,()=>{i.spec.render(i.el,o,i.props,i.ctx)})})}export function screenEdge(t,r,e){const n=t.spec.background;if(!r||n===null)return;const[o,i,c,f]=r.corners,d=(y,S)=>Math.hypot(S[0]-y[0],S[1]-y[1]),[g,h]=t.size,$=Math.min(d(o,i)/g,d(f,c)/g,d(o,f)/h,d(i,c)/h),w=Math.min(Math.ceil(e/Math.max($,.001)),Math.max(g,h)),p=`0 0 0 ${String(w)}px ${n}`;t.edge!==p&&(t.el.style.boxShadow=p,t.edge=p)}

package/dist/node_modules/@allyhub/scenery-host/dist/layer/state.d.ts

@@ -0,0 +1,110 @@
+import type { CameraState, Move } from "@allyhub/scenery";
+import type { EmbeddedVideo, GraphicLayer, StageContext } from "@allyhub/video-core";
+import type { SceneryPage } from "../page/page.js";
+import type { signatureOf } from "../signature.js";
+import type { Screen, SceneryLayerProps } from "./types.js";
+/** A screen as mounted: its element, and its video or its layers with their own elements and contexts. */
+export interface MountedScreen {
+    mesh: string;
+    spec: Screen;
+    /** The element placed on the frame (its transform). */
+    el: HTMLElement;
+    /** What it shows, inside el: its layers or its video, and its depth of field's filter. */
+    surface: HTMLElement;
+    /** Its content's pixels: the layers' size, or the video's once it has loaded. */
+    size: [number, number];
+    /** The screen's time at scenery time. */
+    timeAt: (local: number) => number;
+    /** Its cues as stretches: scenery seconds, the screen's, and the speed. */
+    stretches?: {
+        from: number;
+        to: number;
+        video: [number, number];
+        speed: number;
+    }[];
+    /** The outer layer's context: what a video's frame is waited for with. */
+    ctx: StageContext;
+    /** Its depth of field's filter, once a camera with an aperture has drawn it. */
+    focus?: {
+        svg: SVGSVGElement;
+        id: string;
+        markup: string;
+    };
+    /** Its background's band past its edge, as last set (screenEdge). */
+    edge?: string;
+    video?: EmbeddedVideo;
+    layers: {
+        spec: GraphicLayer;
+        props: object;
+        el: HTMLElement;
+        ctx: StageContext;
+        start: number;
+        end: number;
+    }[];
+}
+/** A scenery layer drawn in this page: where it is, and its scenery's page once built. */
+export interface Drawn {
+    props: SceneryLayerProps;
+    ctx: StageContext;
+    page?: SceneryPage;
+    /** The page half's signature, loaded with it: set in the same render as the pixels. */
+    sign?: typeof signatureOf;
+    /** The layer's element: its parent is its part's. */
+    el: HTMLElement;
+    canvas: HTMLCanvasElement;
+    /** Box in the frame's pixels. */
+    px: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    screens: MountedScreen[];
+    /** The scenery time of a word or anchor reference of its part, for moves timed by them. */
+    time: (ref: string) => number;
+    /** With a sensor: its moiré over the screens, multiplying them (under the scenery's picture). */
+    moire?: HTMLCanvasElement;
+    /** Whether it said its screens are drawn over the scenery, not in it. */
+    fellBack?: boolean;
+}
+/** The scenery layers of this page by name, for projectScenery. */
+export declare const registry: Map<string, Drawn[]>;
+/** Scenery time at a film time, as the layer's `time` has it. */
+export declare const sceneryAtFilm: (props: SceneryLayerProps, filmT: number) => number;
+/** Scenery time at the layer's part time t: on the film's clock, so it runs on across parts. */
+export declare const sceneryTime: (d: Drawn, t: number) => number;
+/**
+ * Scenery time of a reference: an anchor of any part of the output ("@press":
+ * this part's own first, StageContext.film), else a word of this part.
+ */
+export declare const refScenery: (props: SceneryLayerProps, ctx: StageContext, ref: string) => number;
+/** The camera a layer is drawn from: an outer video's (footage({ camera })), else its own. */
+export declare const cameraOf: (d: Drawn) => CameraState | string | Move;
+/**
+ * A layer's window on its output's film clock ([from, to) of its own
+ * video's), the part it is measured in, that part's start, and the way
+ * from its video's clock to the output's (`toOuter`, at `speed`); none for
+ * a scenery in a video on a screen, which that video's own check measures.
+ */
+export declare function windowOf(d: Drawn): {
+    from: number;
+    to: number;
+    part: string | undefined;
+    partStart: number;
+    speed: number;
+    toOuter: (x: number) => number;
+} | undefined;
+/** An error with the rule it is said under, as the runtime reads it. */
+export type Coded = Error & {
+    code?: string;
+};
+/**
+ * What was thrown, said with `prefix` and under its rule: a SceneryError's
+ * kind's, else the code it carried (a screen's layer's own).
+ */
+export declare function coded(e: unknown, prefix?: string): Coded;
+/** Runs work, what it throws said under its rule. */
+export declare function ruled<T>(run: () => T, prefix?: string): T;
+/** What a scenery layer's measurement throws, said with the layer and its part, under its rule. */
+export declare function named<T>(layer: string, part: string | undefined, run: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=state.d.ts.map

package/dist/node_modules/@allyhub/scenery-host/dist/layer/types.d.ts

@@ -0,0 +1,239 @@
+import type { CameraState, GlassOptions, Move, PanelOptions, Scenery, SceneryProp, ScreenLightBase, SensorOptions } from "@allyhub/scenery";
+import type { GraphicLayer, LayerTiming, PieceDefinition, WordRef } from "@allyhub/video-core";
+/** A layer's place in its part: its timing, and where it is in the stack. */
+export interface LayerOptions extends LayerTiming {
+    /**
+     * "front" (default): at its place in the part's layers, over those
+     * listed before it. "behind-person": right over the part's own footage
+     * and under its speaker, cut out with the take's person matte.
+     * "overlay": over the finished picture, as an app lays captions over a
+     * video after it is filmed: over every other layer, and not marked by
+     * the camera (`capture`), motion blur, `post` or the LUT.
+     */
+    z?: "front" | "behind-person" | "overlay";
+}
+/** A rectangle as fractions of the frame: x, y, width, height. */
+export type SceneryBox = readonly [x: number, y: number, w: number, h: number];
+export interface SceneryLayerOptions extends LayerOptions {
+    /** A camera, the name of one of the scenery's cameras or moves, or a move of its own. */
+    camera: CameraState | string | Move;
+    /** Where it is drawn, as fractions of the frame; default the whole frame. The camera's aspect is the box's. */
+    box?: SceneryBox | "full";
+    /**
+     * A colour behind the scenery, or "transparent": the layers listed before
+     * it show through. Default the scenery's own: what its build set as the
+     * scene's background (an HDRI with w.environment(…, { background: true }),
+     * a colour), else transparent.
+     */
+    background?: string;
+    /**
+     * The scenery's time from the film's (the seconds of the output this layer
+     * is in): `{ from }` is the scenery's time at the film's start (default 0:
+     * the scenery's clock is the film's), or a function of the film's time.
+     * The scenery runs on across the output's parts and cuts.
+     */
+    time?: {
+        from?: number;
+    } | ((t: number) => number);
+    /**
+     * `scale`: the share of the layer's size each way it is drawn at, then
+     * shown at its size. Default 0.5, the fastest; 1 draws every pixel, above
+     * 1 draws larger and shrinks (supersampling). `focusLevels`: with a
+     * camera that has an aperture, how many Gaussian levels a screen's blur,
+     * which grows across a turned screen, is mixed from (default 8; 1 blurs
+     * the whole screen by its mean, the fastest).
+     */
+    quality?: {
+        scale?: number;
+        focusLevels?: number;
+    };
+    /**
+     * The sensor that films the scenery, as a phone's does: its screens show
+     * the moiré its Bayer grid makes of their pixels. `photosites` across
+     * the frame's longer side (default 4032), the lens's own blur in
+     * photosites (`lens`, default 0.35), the moiré's strength (`moire`,
+     * default 1, 0 for none), how much false colour the phone's processing
+     * leaves (`chroma`, 0–1, default 0.3) and the lens's distortion before
+     * the phone corrects it, which bends the bands (`distortion`, k1 over the
+     * frame's half diagonal, default -0.03). Without it, no moiré.
+     */
+    sensor?: SensorOptions;
+    /** What projectScenery() and the facts call this layer; default "scenery". */
+    name?: string;
+    /**
+     * Screens: content drawn by AllyHub layers on named meshes of the scenery
+     * (a monitor's screen, a phone's). The mesh's own +Z face shows it; the
+     * mesh itself is drawn as a hole, so what is in front of it still covers it.
+     */
+    screens?: Readonly<Record<string, Screen>>;
+    /**
+     * The props this layer brings into the scenery (a person's stand-in in a shot's pose, a pointer held to a
+     * screen), each a SceneryProp: built once the scenery is built and its bake laid, so never in the bake and
+     * never stopping one from fitting; lit as the scenery's unbaked things are; posed at each moment from t
+     * alone; shown only in the layers that add it.
+     */
+    props?: readonly SceneryProp[];
+}
+/** Marks what screen() made. */
+export declare const SCREEN: unique symbol;
+/**
+ * What a screen shows: a video of the project (the piece imported from its
+ * item), or graphic layers drawn at the screen's time on `size` px.
+ */
+export interface Screen {
+    [SCREEN]: true;
+    /** A video item's piece, as imported; or none, and `layers`. */
+    video?: PieceDefinition;
+    layers: readonly GraphicLayer[];
+    size: readonly [number, number];
+    time: {
+        from?: number;
+    } | ((t: number) => number);
+    /** When the screen's time is 0: a scenery time, or a reference of its part. */
+    start?: WordRef;
+    /** The screen's own moment that plays at start: seconds, or (a video) its own reference. */
+    cue?: number | string;
+    /** The screen's own moments (keys) put on the scenery's: references of the film (values). */
+    cues?: Readonly<Record<string, string | number>>;
+    background: string | null;
+    dur?: number;
+    /** Its physical pixels, for a sensor's moiré (scenery({ sensor })). */
+    pixels?: PanelOptions;
+    /** Its glass: what it reflects of the scenery over what it shows. */
+    glass?: GlassOptions;
+    /**
+     * Drawn in the scenery, its picture a texture of the scenery's, as bright as
+     * `brightness`, lighting the scenery by its picture unless `light` is false;
+     * false: drawn over the scenery (screen(…, { inScenery })).
+     */
+    inScenery: false | {
+        brightness: number;
+        light: false | {
+            cells: [number, number];
+            specular: boolean;
+            /** The steady light the scenery already has from it, or null. */
+            base: {
+                brightness: number;
+                color: string | readonly [number, number, number];
+            } | null;
+        };
+    };
+}
+export interface ScreenOptions {
+    /**
+     * When the screen's time is 0 (its video's first moment): seconds of the
+     * scenery's time, or a word or anchor reference of the part that shows the
+     * scenery ("@demo"). Default 0. The screen follows the scenery's time, so it
+     * plays on across cuts between parts that carry the scenery's time on.
+     */
+    start?: WordRef;
+    /**
+     * The screen's own moment that plays at `start` (default 0, its first):
+     * seconds of its time, or for a video a reference of its own, an anchor
+     * of one of its parts ("@click", "@/click", "@click+0.2") or a part's
+     * key. `screen(demo, { start: "@press", cue: "@click" })` plays the
+     * demo's click as the scenery's part says "press".
+     */
+    cue?: number | string;
+    /**
+     * The screen's own moments put on the scenery's clock, several at once:
+     * each key, a moment of the screen (a video's own reference, "@click",
+     * or seconds of its time as a string, "2.5"), plays at its value, a
+     * reference of the film ("@press", any part's) or a scenery time.
+     * Between two cues it plays at the speed that joins them; before the
+     * first and after the last, at its own. `scenery-screen` reports each
+     * stretch's speed. Instead of start and cue.
+     */
+    cues?: Readonly<Record<string, string | number>>;
+    /** Or the screen's time from the scenery's time: `{ from }` (an offset), or a function. */
+    time?: {
+        from?: number;
+    } | ((t: number) => number);
+    /** Layers only: the content's pixels; default 1920 × 1080. A video's are its format's. */
+    size?: readonly [number, number];
+    /** A colour behind the content, or "transparent"; default black, as a screen that is on. */
+    background?: string;
+    /**
+     * Its physical pixels, which a sensor's moiré beats against
+     * (scenery({ sensor })): `density` physical pixels per content pixel each
+     * way (default 2, a Retina laptop's), and how much the dark lines
+     * between their rows darken them, `rows` (0–1, default 0.15).
+     */
+    pixels?: PanelOptions;
+    /**
+     * Its glass: what its front reflects of the scenery over what it shows,
+     * as glass does (the lamps' highlights, what is in front of it, the
+     * room), by Fresnel. `reflectance` head on (default 0.04, bare glass;
+     * an anti-reflective coating 0.005 to 0.01), `roughness` of its finish
+     * (default 0.05, glossy; 0.3 to 0.5 matte anti-glare, which blurs the
+     * reflection the more the farther what it reflects is behind the
+     * glass), `scale` of the reflection's pixels (default 1). `{}` takes
+     * the defaults; without it the screen shows its content alone.
+     */
+    glass?: GlassOptions;
+    /** Layers only: the screen's length in seconds, their ctx.dur and default end; default its time at the scenery layer's end. */
+    dur?: number;
+    /**
+     * Where the screen is drawn. In the scenery (the default where the browser
+     * can, Chrome's HTML-in-Canvas, which AllyHub's own Chrome has): its
+     * content's picture is a texture its mesh shows, drawn with the scenery
+     * (toned by the camera's exposure, in its depth of field, under its glass
+     * and a sensor's moiré), and it lights the scenery's lit materials by what
+     * it shows (`light`; `w.screenPicture(name)` gives a scenery's own code the
+     * same picture). `brightness` is what its white gives out, scene-linear:
+     * in a scenery lit in physical units and drawn by a camera with an `ev`,
+     * nits (cd/m²; a laptop's screen 200–400, a phone's 400–800); default 1,
+     * the scenery's white for a camera without one. `light: false` leaves the
+     * scenery unlit by it; `light: { cells }` cuts it into that many cells
+     * across and down (default 8 × 5) for its diffuse light, and
+     * `light: { specular: false }` keeps that diffuse light and leaves out
+     * its reflection (default true: reflected, as rough as each material is,
+     * fading past the screen's edges as wide as it blurs).
+     * `light: { base: { brightness, color } }` says what steady light the
+     * scenery already has from the screen (a bake of it as a grey-white pane,
+     * an area light on its face, a probe's pane of it): the screen then adds
+     * only what its picture differs by, cell by cell, in its diffuse light
+     * and its reflection, less where the picture is darker than it
+     * (`brightness` default the screen's own, `color` a hex colour as a
+     * light's, or linear RGB; default "#ffffff"). `false`: drawn
+     * over the scenery, the screen's content laid on the scenery's picture where
+     * the screen shows, as a browser without HTML-in-Canvas (a preview pane)
+     * always draws it.
+     */
+    inScenery?: boolean | {
+        brightness?: number;
+        light?: boolean | {
+            cells?: readonly [number, number];
+            specular?: boolean;
+            base?: ScreenLightBase | null;
+        };
+    };
+}
+/** The props of a scenery layer, as scenery() makes them. */
+export interface SceneryLayerProps {
+    scenery: Scenery;
+    camera: CameraState | string | Move;
+    box: SceneryBox;
+    /** A colour, null for none, or absent: the scenery's own. */
+    background?: string | null;
+    time: {
+        from?: number;
+    } | ((t: number) => number);
+    scale: number;
+    focusLevels: number;
+    name: string;
+    screens: Readonly<Record<string, Screen>>;
+    sensor?: SensorOptions;
+    props: readonly SceneryProp[];
+}
+/** Where a point or a named object of a scenery layer is on the frame at part time t. */
+export interface SceneryPoint {
+    /** Pixels from the frame's left and top. */
+    x: number;
+    y: number;
+    /** In front of the camera and inside the layer's box. */
+    inView: boolean;
+    /** Distance along the camera's view, m. */
+    depth: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/node_modules/@allyhub/scenery-host/dist/measure/contacts.d.ts

@@ -0,0 +1,45 @@
+import type { Contact } from "@allyhub/scenery";
+import { type Vec3 } from "../vec.js";
+import { type Solid } from "./solid.js";
+export interface ContactOptions {
+    /** Pairs closer than this are measured, m. */
+    near: number;
+    /** What counts as touching, m. */
+    tolerance: number;
+    /** Surface samples per object for the depth's lower bound. */
+    samples: number;
+    /** The direction a lift to clear moves either object. */
+    lift: Vec3;
+    /** Whether each solid is closed: inside it means something. */
+    closed(s: Solid): boolean;
+    /** manifold-3d, loaded on demand; undefined where it could not be. */
+    manifold?: () => Promise<ManifoldModule | undefined>;
+    /** Seeds the surface samples. */
+    seed: number;
+    /** Measure the pair whatever the distance. */
+    always?: boolean;
+}
+/** What contacts needs of manifold-3d. */
+export interface ManifoldModule {
+    Mesh: new (o: {
+        numProp: number;
+        vertProperties: Float32Array;
+        triVerts: Uint32Array;
+    }) => {
+        merge(): boolean;
+    };
+    Manifold: new (mesh: unknown) => {
+        status(): string;
+        intersect(other: unknown): {
+            volume(): number;
+            delete(): void;
+        };
+        volume(): number;
+        delete(): void;
+    };
+}
+/** Points on a solid's surface, area-weighted, the same every time for a seed; its vertices after them when asked. */
+export declare function samplesOn(s: Solid, n: number, seed: number, vertices?: boolean): Vec3[];
+/** The pair's contact, or undefined when they are farther apart than `near` (unless always). */
+export declare function contactOf(a: Solid, b: Solid, opts: ContactOptions): Promise<Contact | undefined>;
+//# sourceMappingURL=contacts.d.ts.map

package/dist/node_modules/@allyhub/scenery-host/dist/measure/facts.d.ts

@@ -0,0 +1,86 @@
+import { type CameraState } from "@allyhub/scenery";
+import { type PanelOptions, type SensorOptions } from "@allyhub/scenery";
+import type { Move } from "@allyhub/scenery";
+import type { FactData } from "@allyhub/video-core";
+import { type SceneryPage } from "../page/page.js";
+/** Where a scenery fact is from: the layer, and its window on its part's clock. */
+export interface LayerPlace {
+    layer: string;
+    start: number;
+    end: number;
+}
+/** The kinds of fact a scenery layer measures. */
+export type LayerFactKind = "scenery-contact" | "scenery-support" | "mesh-health" | "camera-clearance" | "camera-motion" | "scenery-screen" | "scenery-bake";
+/** A fact of a scenery layer, its data as video-core's FactData has it. */
+export type LayerFact = {
+    [K in LayerFactKind]: {
+        kind: K;
+        data: FactData[K];
+    };
+}[LayerFactKind];
+export interface LayerFactOptions extends LayerPlace {
+    /** Scenery time at the layer's own time (seconds from its start). */
+    sceneryAt(local: number): number;
+    camera: CameraState | string | Move;
+    /** The scenery time of a word or anchor reference of the layer's part, for moves timed by them. */
+    time?: (ref: string) => number;
+    /** The layer's box, width over height. */
+    aspect: number;
+    /** Camera samples a second; default 30. */
+    fps?: number;
+    /** The layer's box on the frame, px: its size, and where it is ([x, y, width, height]). */
+    frame?: readonly [number, number];
+    box?: readonly [number, number, number, number];
+    /**
+     * Its screens: the mesh each is on, its content's size (px), its cues'
+     * stretches and its smallest text (font size, content px).
+     */
+    /** The sensor that films the layer (scenery({ sensor })), for its moiré. */
+    sensor?: SensorOptions;
+    /** The output's frame, px (the sensor's photosites span its longer side). */
+    output?: readonly [number, number];
+    screens?: readonly {
+        mesh: string;
+        size: readonly [number, number];
+        /** Its physical pixels (screen({ pixels })). */
+        pixels?: PanelOptions;
+        stretches?: readonly {
+            from: number;
+            to: number;
+            video: [number, number];
+            speed: number;
+        }[];
+        text?: number;
+        /**
+         * Where it is drawn at this check, and at what share of the frame's
+         * pixels each way: in the scenery, at the scenery layer's drawing scale
+         * (its quality.scale); over the scenery, at the frame's own (1). Its
+         * text on the frame is that much of its size there, up to 1.
+         */
+        drawn?: {
+            in: "scenery" | "over";
+            scale: number;
+        };
+    }[];
+    /** The scenery's module, a project path, for its bake's fact. */
+    file?: string;
+    /**
+     * Measure the scenery itself too (contacts, support, meshes, its bake); default
+     * true. A scenery drawn inside another video's stretch is measured by that
+     * video's own check.
+     */
+    scenery?: boolean;
+}
+/** A screen at one sampled moment: its corners on the frame and its numbers then. */
+export interface ScreenSample {
+    /** Part time, s. */
+    t: number;
+    /** Top left, top right, bottom right, bottom left of its content, frame px. */
+    corners: [number, number][];
+    share: number;
+    scale: [number, number];
+    angle: number;
+    hidden?: number;
+}
+export declare function layerFacts(page: SceneryPage, o: LayerFactOptions): Promise<LayerFact[]>;
+//# sourceMappingURL=facts.d.ts.map

package/dist/node_modules/@allyhub/scenery-host/dist/measure/facts.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{blurDiameter as re}from"@allyhub/scenery";import{motionOf as ie}from"@allyhub/scenery";import{moireBand as ce,moireCamera as de,moireScreen as le}from"@allyhub/scenery";import{apply as me,homography as he,screenOnFrame as fe}from"@allyhub/scenery";import{drawnCamera as pe}from"../page/page.js";import{clearanceOf as ue,measure as ge,nearPlaneOf as ye,solidsOf as be}from"./index.js";const w=(n,t,r)=>n?{least:t<n.least?t:n.least,leastAt:t<n.least?r:n.leastAt,most:t>n.most?t:n.most,mostAt:t>n.most?r:n.mostAt}:{least:t,leastAt:r,most:t,mostAt:r},Z=n=>n?Math.min(1,n.scale):1;function L(n,t){const r=new Map,h=[];for(const u of n)for(const g of u.keys){const m=r.get(g);m&&u.t-m.to<=t*1.5?m.to=u.t:(m&&h.push({key:g,...m}),r.set(g,{from:u.t,to:u.t}))}for(const[u,g]of r)h.push({key:u,...g});return h}export async function layerFacts(n,t){const r={layer:t.layer,start:t.start,end:t.end},h=[],u=t.sceneryAt(0),g=t.scenery===!1?{contacts:[],support:[],health:[]}:await ge(n,{t:u,near:.01,tolerance:.001,samples:400,grid:5,all:!1,volume:!0},t.time),m=n.bake.state;t.scenery!==!1&&m.digest!==""&&h.push({kind:"scenery-bake",data:{...r,laid:m.laid!==null,asked:m.asked,digest:m.digest,renderer:m.renderer,...m.laid?{bakedOn:m.laid.renderer}:{},...t.file===void 0?{}:{file:t.file}}});for(const e of g.contacts){const a=Math.max(e.depth?.aInB??0,e.depth?.bInA??0);h.push({kind:"scenery-contact",data:{...r,a:e.a,b:e.b,crossing:e.crossing,touching:e.touching,...e.gap!==void 0?{gap:e.gap}:{},...e.area!==void 0?{area:e.area}:{},...e.curve?{curve:e.curve.length}:{},...e.within?{within:e.within}:{},...e.depth?{depth:a}:{},...e.lift?{lift:{a:e.lift.a,b:e.lift.b}}:{},...e.volume!==void 0?{volume:e.volume}:{},...e.volumeMissing?{volumeMissing:e.volumeMissing}:{},...e.missing?{missing:e.missing}:{}}})}for(const e of g.support)h.push({kind:"scenery-support",data:{...r,object:e.path,gap:e.gap,sunk:e.sunk,on:e.on.map(a=>a.path),footprintShare:e.footprintShare,...e.margin!==void 0?{margin:e.margin}:{},nothingBelow:e.nothingBelow}});for(const e of g.health)e.closed&&e.degenerate===0&&!e.selfIntersections||h.push({kind:"mesh-health",data:{...r,object:e.path,triangles:e.triangles,closed:e.closed,openEdges:e.openEdges,nonManifoldEdges:e.nonManifoldEdges,degenerate:e.degenerate,selfIntersections:e.selfIntersections}});const B=t.fps??30,E=1/B,N=t.end-t.start,G=[],H=[],J=[],K=new Map;let O;const Q=Math.max(1,Math.round(B/10));let P;const f=t.frame??[1080,1920],T=[Math.max(64,Math.round(f[0]/4)),Math.max(64,Math.round(f[1]/4))],U=(t.screens??[]).map(e=>({mesh:e.mesh,size:e.size,shown:[],samples:[],...e.stretches?{stretches:e.stretches}:{},...e.text===void 0?{}:{text:e.text},...e.pixels?{pixels:e.pixels}:{},...e.drawn?{drawn:e.drawn}:{}}));for(let e=0,a=0;a<=N+1e-9;e++,a=e*E){const d=t.sceneryAt(a),te=n.stateFrom(t.camera,d,t.aspect,t.time),R=n.aim(te,t.aspect),o=R.resolved,D=pe(R),l=Math.round((t.start+a)*1e6)/1e6;if(G.push({t:l,position:o.position,forward:o.forward,up:o.up,right:o.right,lens:o.lens,yaw:D.yaw,pitch:D.pitch,roll:D.roll,...o.target?{target:o.target}:{}}),e%Q!==0)continue;for(const s of U){const y=n.screens.quad(s.mesh,o,f),W=y!==void 0&&y.angle<90;if(s.shown.push({t:l,keys:W?["shown"]:[]}),!y||!W)continue;const b=fe(s.size[0],s.size[1],y.corners,f,y.angle);s.share=w(s.share,b.share,l);const ne=w(s.scale,b.scale.least,l);s.scale=w(ne,b.scale.most,l),s.angle=w(s.angle,b.angle,l);const X=o.dof?n.screens.face(s.mesh):void 0;if(X&&o.dof){const c=[[0,0],[1,0],[1,1],[0,1]].map(([I,S])=>{const z=X.point(I,S).map((A,v)=>A-(o.position[v]??0));return(z[0]??0)*o.forward[0]+(z[1]??0)*o.forward[1]+(z[2]??0)*o.forward[2]}),j=Math.min(...c),F=Math.max(...c),C=c.map(I=>re(o,I,f[1])),k=o.dof.focus>=j&&o.dof.focus<=F;s.blur=w(s.blur,k?0:Math.min(...C),l),s.blur=w(s.blur,Math.max(...C),l)}if(t.sensor){const c=n.screens.face(s.mesh),j=de(o,t.output??f,f[1],t.sensor,t.box?[t.box[0],t.box[1]]:[0,0]),F=c?le({quad:y.corners,corners:[c.point(0,0),c.point(1,0),c.point(1,1),c.point(0,1)],size:s.size,camera:o,...s.pixels?{panel:s.pixels}:{}}):void 0,C=he(s.size[0],s.size[1],y.corners);let k={depth:0,period:1/0};if(F&&C)for(let S=1;S<8;S++)for(let z=1;z<12;z++){const A=me(C,s.size[0]*z/12,s.size[1]*S/8);if(A[0]<0||A[1]<0||A[0]>f[0]||A[1]>f[1])continue;const v=ce(F,j,A);v&&v.depth>k.depth&&(k=v)}const I=s.moire?.most??-1;s.moire=w(s.moire,k.depth,l),k.depth>I&&Number.isFinite(k.period)&&(s.moirePeriod=k.period)}const x=await n.screens.hidden(s.mesh,R,T[0],T[1]);if(x){const c=s.hidden?.most??-1;s.hidden=w(s.hidden,x.hidden,l),x.hidden>c&&(s.by=x.by)}const[oe,ae]=t.box??[0,0],Y=c=>Math.round(c*10)/10;s.samples.push({t:l,corners:y.corners.map(([c,j])=>[Y(c+oe),Y(j+ae)]),share:b.share,scale:[b.scale.least,b.scale.most],angle:b.angle,...x?{hidden:Math.round(x.hidden*1e4)/1e4}:{}})}P&&n.animated&&P.refresh();const se=P??=be(n),M=ue(se,o.position,ye(o));M.nearest&&(!O||M.nearest.distance<O.distance)&&(O={object:M.nearest.path,distance:M.nearest.distance,t:l});for(const s of M.inside)K.set(s.path,s.closed);J.push({t:l,keys:M.inside.map(s=>s.path)}),H.push({t:l,keys:M.nearCut})}const q=E*Q,_=L(J,q),$=L(H,q);h.push({kind:"camera-clearance",data:{...r,...O?{nearest:O}:{},inside:_.map(e=>({object:e.key,closed:K.get(e.key)??!1,from:e.from,to:e.to})),nearCut:$.map(e=>({object:e.key,from:e.from,to:e.to}))}});for(const e of U){const a=d=>({least:Math.round(d.least*1e4)/1e4,leastAt:d.leastAt,most:Math.round(d.most*1e4)/1e4,mostAt:d.mostAt});h.push({kind:"scenery-screen",data:{...r,screen:e.mesh,size:[e.size[0],e.size[1]],frame:[f[0],f[1]],shown:L(e.shown,q).map(d=>({from:d.from,to:d.to})),...e.share?{share:a(e.share)}:{},...e.scale?{scale:a(e.scale)}:{},...e.angle?{angle:a(e.angle)}:{},...e.blur?{blur:a(e.blur)}:{},...e.moire?{moire:{...a(e.moire),...e.moirePeriod!==void 0?{period:Math.round(e.moirePeriod*10)/10}:{}}}:{},...e.hidden?{hidden:{...a(e.hidden),by:e.by??[]}}:{},samples:e.samples,...e.stretches?{stretches:[...e.stretches]}:{},...e.drawn?{drawn:e.drawn}:{},...e.text!==void 0&&e.scale?{text:{size:e.text,onFrame:[Math.round(e.text*e.scale.least*Z(e.drawn)*100)/100,Math.round(e.text*e.scale.most*Z(e.drawn)*100)/100]}}:{}}})}const ee=n.cutsOf(t.camera,t.time),V=[];for(const e of ee)for(let a=0,d=0;d<=N+1e-9;a++,d=a*E)if(t.sceneryAt(d)>=e){V.push(Math.round((t.start+d)*1e6)/1e6);break}const i=ie(G,V),p=e=>({peak:e.peak,at:e.at});return h.push({kind:"camera-motion",data:{...r,fps:B,length:i.length,peaks:{truck:p(i.truck),pedestal:p(i.pedestal),dolly:p(i.dolly),pan:p(i.pan),tilt:p(i.tilt),roll:p(i.roll),zoom:p(i.zoom),speed:p(i.speed),turn:p(i.turn),acceleration:p(i.acceleration),jerk:p(i.jerk)},smoothness:i.smoothness,step:i.step,...i.cuts.length>0?{cuts:i.cuts}:{}}}),n.pose(u,t.time),h}

package/dist/node_modules/@allyhub/scenery-host/dist/measure/health.d.ts

@@ -0,0 +1,10 @@
+import type { MeshHealth } from "@allyhub/scenery";
+import type { Solid } from "./solid.js";
+/** Vertices closer than this are one, m. */
+export declare const WELD = 0.00001;
+/** Above this many triangles, self-intersections are not counted (said so). */
+export declare const SELF_LIMIT = 200000;
+/** Each vertex's welded index. */
+export declare function welded(s: Solid): Uint32Array;
+export declare function healthOf(s: Solid): MeshHealth;
+//# sourceMappingURL=health.d.ts.map