@allyhub/sdk 0.1.0-alpha.8 → 0.2.0-next.0

package/node_modules/@allyhub-next/scenery/dist/moire.d.ts

@@ -0,0 +1,136 @@
+import { type ResolvedCamera } from "./camera.js";
+import { type Px } from "./screen.js";
+import type { Vec3 } from "./vec.js";
+/** A sensor that films the scenery layer (scenery({ sensor })). */
+export interface SensorOptions {
+    /** Photosites across the frame's longer side (a 12 MP phone's 4:3 sensor, cropped to 16:9: 4032). */
+    photosites?: number;
+    /** The lens's own blur, a Gaussian's standard deviation in photosites. */
+    lens?: number;
+    /** How strong the moiré is, a share of what the model gives (0: none). */
+    moire?: number;
+    /**
+     * How much of the false colour the phone's processing leaves (0: bands of
+     * light and dark only; 1: as the Bayer grid made them).
+     */
+    chroma?: number;
+    /**
+     * The lens's barrel (negative) or pincushion (positive) distortion before
+     * the phone corrects the picture, k1 over the frame's half diagonal: the
+     * sensor's grid, as the corrected picture sees it, bends, and so do the
+     * bands.
+     */
+    distortion?: number;
+}
+/** A screen's physical pixels (screen({ pixels })). */
+export interface PanelOptions {
+    /** Physical pixels per content pixel each way (a Retina laptop: 2). */
+    density?: number;
+    /** How much the dark lines between rows of pixels darken them (0–1). */
+    rows?: number;
+}
+export declare const SENSOR_DEFAULTS: {
+    photosites: number;
+    lens: number;
+    moire: number;
+    chroma: number;
+    distortion: number;
+};
+export declare const PANEL_DEFAULTS: {
+    density: number;
+    rows: number;
+};
+/**
+ * The depth a stripe a third of a pixel wide gives its fundamental,
+ * against its mean (2 sin(π/3) / (π/3)), half of it left by a phone's
+ * demosaicing: with a phone's lens (sharp to about half at the sensor's
+ * Nyquist), a screen at the worst distance shows bands of a fifth to a
+ * third of its brightness.
+ */
+export declare const STRIPE_DEPTH: number;
+/** What the moiré of one screen at one moment is drawn from. */
+export interface MoireScreen {
+    /** The homography from the layer's px to the content's px (row-major, 3 × 3). */
+    inverse: number[];
+    /** The content's size, px. */
+    size: [number, number];
+    /** Physical pixels per content pixel. */
+    density: number;
+    /** How much the rows darken. */
+    rows: number;
+    /** Depth along the view at the content's (0, 0), and its change per content px along x and y, m. */
+    depth: [d0: number, dx: number, dy: number];
+}
+/** The camera's part: the sensor and its depth of field. */
+export interface MoireCamera {
+    /** Layer px per photosite. */
+    pitch: number;
+    /** The lens's blur, photosites. */
+    lens: number;
+    strength: number;
+    /** The share of false colour left. */
+    chroma: number;
+    /** k1, and the frame's centre and half diagonal in layer px. */
+    distortion: {
+        k1: number;
+        centre: Px;
+        radius: number;
+    };
+    /**
+     * The circle of confusion's diameter in layer px at a depth d:
+     * k · |d − focus| / max(d, near); none without an aperture.
+     */
+    blur?: {
+        k: number;
+        focus: number;
+        near: number;
+    };
+}
+/**
+ * The factor per channel (red, green, blue) a layer pixel of a screen is
+ * multiplied by; undefined where the pixel is not on the screen.
+ */
+export declare function moireAt(screen: MoireScreen, camera: MoireCamera, at: Px): [number, number, number] | undefined;
+/**
+ * The deepest band at a layer pixel of a screen, of any channel and of
+ * the stripes or the rows: how much it darkens at its darkest (0–1, before
+ * the phone takes out its colour) and how far apart its bands are, layer
+ * px. Undefined off the screen.
+ */
+export declare function moireBand(screen: MoireScreen, camera: MoireCamera, at: Px): {
+    depth: number;
+    period: number;
+} | undefined;
+/** The most screens one layer's moiré is drawn for. */
+export declare const MOIRE_SCREENS = 4;
+/**
+ * The same arithmetic for the page: a fragment shader over the layer that
+ * gives, at each pixel, the factors of the nearest screen there (clear
+ * elsewhere), to multiply what is under it by.
+ */
+export declare const MOIRE_GLSL: string;
+/** A 3 × 3 matrix's inverse (row-major); undefined when it has none. */
+export declare function invert3(m: readonly number[]): number[] | undefined;
+/**
+ * One screen's part of the moiré at a moment: its content's corners on the
+ * layer (top left, top right, bottom right, bottom left, layer px) and in
+ * the scenery, its content's size and its panel.
+ */
+export declare function moireScreen(o: {
+    quad: readonly [Px, Px, Px, Px];
+    corners: readonly [Vec3, Vec3, Vec3, Vec3];
+    size: readonly [number, number];
+    camera: ResolvedCamera;
+    panel?: PanelOptions;
+}): MoireScreen | undefined;
+/**
+ * The camera's part: its sensor on a frame `frame` px (the photosites span
+ * its longer side) and, with an aperture, its blur on a layer `height` px
+ * tall (blurDiameter's frame).
+ */
+export declare function moireCamera(camera: ResolvedCamera, frame: readonly [number, number], height: number, sensor?: SensorOptions, 
+/** Where the layer's box starts on the frame, px. */
+origin?: Px): MoireCamera;
+/** Problems with a sensor's or a panel's options, each a sentence. */
+export declare function moireProblems(sensor: SensorOptions | undefined, panel: PanelOptions | undefined): string[];
+//# sourceMappingURL=moire.d.ts.map

package/node_modules/@allyhub-next/scenery/dist/moire.js

@@ -0,0 +1,93 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{blurDiameter as z}from"./camera.js";import{homography as C}from"./screen.js";export const SENSOR_DEFAULTS={photosites:4032,lens:.35,moire:1,chroma:.3,distortion:-.03},PANEL_DEFAULTS={density:2,rows:.15},STRIPE_DEPTH=2*Math.sin(Math.PI/3)/(Math.PI/3)/2;const g=2*Math.PI,P=o=>Math.abs(o)<1e-6?1:Math.sin(Math.PI*o)/(Math.PI*o);function R(o,n){if(n===1){const i=Math.round(o[0]+o[1]),t=Math.round(o[0]-o[1]);return[(i+t)/2,(i-t)/2]}return[Math.round(2*o[0])/2,Math.round(2*o[1])/2]}const T={0:[0,0],1:[1,0],2:[1,1]};function D(o,n,i,t,f,s,e){return E(o,n,i,t,f,s,e).factor}function E(o,n,i,t,f,s,e){const r=s.pitch,c=[i[0]*r,i[1]*r],d=F(t,s),h=[d[0]/r,d[1]/r],u=R(c,o),p=T[o],a=[(c[0]-u[0])/r,(c[1]-u[1])/r],m=Math.hypot(a[0],a[1]);if(m>=.5)return{factor:1,depth:0,period:1/0};const w=c[0]*c[0]+c[1]*c[1],S=Math.exp(-2*Math.PI**2*s.lens**2*w),x=e/4,b=Math.exp(-2*Math.PI**2*x**2*(i[0]*i[0]+i[1]*i[1])),y=Math.abs(P(c[0])*P(c[1])),M=Math.abs(P(a[0])*P(a[1]))*(1-2*m),l=Math.min(1,s.strength*f*S*b*y*M),v=n-g*(u[0]*h[0]+u[1]*h[1])+g*(u[0]*p[0]+u[1]*p[1]);return{factor:1-l*(1-Math.cos(v))/2,depth:l,period:m>0?1/m:1/0}}function F(o,n){const{k1:i,centre:t,radius:f}=n.distortion,s=o[0]-t[0],e=o[1]-t[1],r=(s*s+e*e)/(f*f),c=1+i*r;return[t[0]+s*c,t[1]+e*c]}const I=[.299,.587,.114];export function moireAt(o,n,i){const t=o.inverse,[f,s]=i,e=(t[6]??0)*f+(t[7]??0)*s+(t[8]??1);if(e<=0)return;const r=((t[0]??0)*f+(t[1]??0)*s+(t[2]??0))/e,c=((t[3]??0)*f+(t[4]??0)*s+(t[5]??0))/e,[d,h]=o.size;if(r<0||c<0||r>d||c>h)return;const u=[((t[0]??0)-(t[6]??0)*r)/e,((t[1]??0)-(t[7]??0)*r)/e],p=[((t[3]??0)-(t[6]??0)*c)/e,((t[4]??0)-(t[7]??0)*c)/e],a=o.density,[m,w,S]=o.depth,x=m+w*r+S*c,b=n.blur?n.blur.k*Math.abs(x-n.blur.focus)/Math.max(x,n.blur.near):0,y=[a*u[0],a*u[1]],M=[a*p[0],a*p[1]],l=[1,1,1];for(const k of[0,1,2]){const A=D(k,g*(a*r-k/3),y,i,STRIPE_DEPTH,n,b),N=D(k,g*a*c,M,i,o.rows*STRIPE_DEPTH,n,b);l[k]=A*N}const v=I[0]*l[0]+I[1]*l[1]+I[2]*l[2];return[v+n.chroma*(l[0]-v),v+n.chroma*(l[1]-v),v+n.chroma*(l[2]-v)]}export function moireBand(o,n,i){const t=o.inverse,[f,s]=i,e=(t[6]??0)*f+(t[7]??0)*s+(t[8]??1);if(e<=0)return;const r=((t[0]??0)*f+(t[1]??0)*s+(t[2]??0))/e,c=((t[3]??0)*f+(t[4]??0)*s+(t[5]??0))/e,[d,h]=o.size;if(r<0||c<0||r>d||c>h)return;const u=[((t[0]??0)-(t[6]??0)*r)/e,((t[1]??0)-(t[7]??0)*r)/e],p=[((t[3]??0)-(t[6]??0)*c)/e,((t[4]??0)-(t[7]??0)*c)/e],a=o.density,[m,w,S]=o.depth,x=m+w*r+S*c,b=n.blur?n.blur.k*Math.abs(x-n.blur.focus)/Math.max(x,n.blur.near):0;let y={depth:0,period:1/0};for(const M of[0,1,2])for(const l of[E(M,g*(a*r-M/3),[a*u[0],a*u[1]],i,STRIPE_DEPTH,n,b),E(M,g*a*c,[a*p[0],a*p[1]],i,o.rows*STRIPE_DEPTH,n,b)])l.depth>y.depth&&(y={depth:l.depth,period:l.period});return y}export const MOIRE_SCREENS=4,MOIRE_GLSL=`#version 300 es
+precision highp float;
+#define SCREENS ${String(MOIRE_SCREENS)}
+uniform int count;
+uniform mat3 inverse[SCREENS];
+uniform vec2 size[SCREENS];
+uniform vec2 panel[SCREENS];
+uniform vec3 depth[SCREENS];
+uniform vec2 layer;
+uniform float pitch;
+uniform float lensBlur;
+uniform float strength;
+uniform vec3 blur;
+uniform float stripeDepth;
+uniform float chroma;
+uniform vec4 distortion;
+out vec4 colour;
+const float PI = 3.14159265358979;
+const float TAU = 6.28318530717959;
+
+float sinc(float x) { return abs(x) < 1e-6 ? 1.0 : sin(PI * x) / (PI * x); }
+
+vec2 nearestPoint(vec2 k, int channel) {
+  if (channel == 1) {
+    float p = floor(k.x + k.y + 0.5);
+    float r = floor(k.x - k.y + 0.5);
+    return vec2(p + r, p - r) / 2.0;
+  }
+  return floor(2.0 * k + 0.5) / 2.0;
+}
+
+vec2 sensorAt(vec2 at) {
+  vec2 d = at - distortion.yz;
+  float r2 = dot(d, d) / (distortion.w * distortion.w);
+  return distortion.yz + d * (1.0 + distortion.x * r2);
+}
+
+float aliased(int channel, float phase, vec2 k, vec2 at, float lines, float blurPx) {
+  vec2 ks = k * pitch;
+  vec2 s = sensorAt(at) / pitch;
+  vec2 g = nearestPoint(ks, channel);
+  vec2 o = channel == 0 ? vec2(0.0) : channel == 1 ? vec2(1.0, 0.0) : vec2(1.0);
+  vec2 ka = (ks - g) / pitch;
+  float fine = length(ka);
+  if (fine >= 0.5) return 1.0;
+  float lens = exp(-2.0 * PI * PI * lensBlur * lensBlur * dot(ks, ks));
+  float sigma = blurPx / 4.0;
+  float defocus = exp(-2.0 * PI * PI * sigma * sigma * dot(k, k));
+  float site = abs(sinc(ks.x) * sinc(ks.y));
+  float outMtf = abs(sinc(ka.x) * sinc(ka.y)) * (1.0 - 2.0 * fine);
+  float d = min(1.0, strength * lines * lens * defocus * site * outMtf);
+  float psi = phase - TAU * dot(g, s) + TAU * dot(g, o);
+  return 1.0 - d * (1.0 - cos(psi)) / 2.0;
+}
+
+void main() {
+  // Layer px, from the top left, at the pixel's centre.
+  vec2 at = vec2(gl_FragCoord.x, layer.y - gl_FragCoord.y);
+  vec3 factor = vec3(1.0);
+  bool on = false;
+  float nearestDepth = 1e9;
+  for (int i = 0; i < SCREENS; i++) {
+    if (i >= count) break;
+    // Sent transposed: m[col][row] is the homography's row, column.
+    mat3 m = inverse[i];
+    float w = m[0][2] * at.x + m[1][2] * at.y + m[2][2];
+    if (w <= 0.0) continue;
+    float u = (m[0][0] * at.x + m[1][0] * at.y + m[2][0]) / w;
+    float v = (m[0][1] * at.x + m[1][1] * at.y + m[2][1]) / w;
+    if (u < 0.0 || v < 0.0 || u > size[i].x || v > size[i].y) continue;
+    float d = depth[i].x + depth[i].y * u + depth[i].z * v;
+    if (d >= nearestDepth) continue;
+    nearestDepth = d;
+    vec2 du = vec2(m[0][0] - m[0][2] * u, m[1][0] - m[1][2] * u) / w;
+    vec2 dv = vec2(m[0][1] - m[0][2] * v, m[1][1] - m[1][2] * v) / w;
+    float D = panel[i].x;
+    float blurPx = blur.x > 0.0 ? blur.x * abs(d - blur.y) / max(d, blur.z) : 0.0;
+    vec2 ku = D * du;
+    vec2 kv = D * dv;
+    vec3 f;
+    for (int c = 0; c < 3; c++) {
+      float stripes = aliased(c, TAU * (D * u - float(c) / 3.0), ku, at, stripeDepth, blurPx);
+      float rows = aliased(c, TAU * D * v, kv, at, panel[i].y * stripeDepth, blurPx);
+      f[c] = stripes * rows;
+    }
+    float light = dot(f, vec3(0.299, 0.587, 0.114));
+    factor = vec3(light) + chroma * (f - vec3(light));
+    on = true;
+  }
+  // Off every screen: nothing (premultiplied).
+  colour = on ? vec4(factor, 1.0) : vec4(0.0);
+}`;export function invert3(o){const[n=0,i=0,t=0,f=0,s=0,e=0,r=0,c=0,d=1]=o,h=s*d-e*c,u=-(f*d-e*r),p=f*c-s*r,a=n*h+i*u+t*p;if(!(Math.abs(a)<1e-18))return[h/a,-(i*d-t*c)/a,(i*e-t*s)/a,u/a,(n*d-t*r)/a,-(n*e-t*f)/a,p/a,-(n*c-i*r)/a,(n*s-i*f)/a]}export function moireScreen(o){const[n,i]=o.size,t=C(n,i,o.quad),f=t?invert3(t):void 0;if(!f)return;const s=o.camera,e=u=>(u[0]-s.position[0])*s.forward[0]+(u[1]-s.position[1])*s.forward[1]+(u[2]-s.position[2])*s.forward[2],[r,c,,d]=o.corners,h=e(r);return{inverse:f,size:[n,i],density:o.panel?.density??PANEL_DEFAULTS.density,rows:o.panel?.rows??PANEL_DEFAULTS.rows,depth:[h,(e(c)-h)/n,(e(d)-h)/i]}}export function moireCamera(o,n,i,t={},f=[0,0]){const s=t.photosites??SENSOR_DEFAULTS.photosites,e={pitch:Math.max(n[0],n[1])/s,lens:t.lens??SENSOR_DEFAULTS.lens,strength:t.moire??SENSOR_DEFAULTS.moire,chroma:t.chroma??SENSOR_DEFAULTS.chroma,distortion:{k1:t.distortion??SENSOR_DEFAULTS.distortion,centre:[n[0]/2-f[0],n[1]/2-f[1]],radius:Math.hypot(n[0],n[1])/2}},r=o.dof;if(r){const c=2*r.focus,d=z(o,c,i)*Math.max(c,o.near)/Math.abs(c-r.focus);e.blur={k:d,focus:r.focus,near:o.near}}return e}export function moireProblems(o,n){const i=[],t=(s,e)=>{s!==void 0&&!(Number.isFinite(s)&&s>0)&&i.push(`${e} is a positive number, not ${String(s)}.`)};t(o?.photosites,"sensor.photosites"),t(o?.lens,"sensor.lens"),t(n?.density,"pixels.density");const f=(s,e,r)=>{s!==void 0&&!(Number.isFinite(s)&&s>=0&&s<=r)&&i.push(`${e} is from 0 to ${String(r)}, not ${String(s)}.`)};return f(o?.moire,"sensor.moire",4),f(o?.chroma,"sensor.chroma",1),o?.distortion!==void 0&&!(Number.isFinite(o.distortion)&&Math.abs(o.distortion)<=.5)&&i.push(`sensor.distortion is from -0.5 to 0.5, not ${String(o.distortion)}.`),f(n?.rows,"pixels.rows",1),i}

package/node_modules/@allyhub-next/scenery/dist/motion.d.ts

@@ -0,0 +1,48 @@
+import type { Channel } from "./report.js";
+import { type Vec3 } from "./vec.js";
+/** A camera at a moment, resolved. */
+export interface CameraSample {
+    t: number;
+    position: Vec3;
+    forward: Vec3;
+    up: Vec3;
+    right: Vec3;
+    /** The lens in the diagonal convention, mm. */
+    lens: number;
+    yaw: number;
+    pitch: number;
+    roll: number;
+    target?: Vec3;
+}
+export interface MotionNumbers {
+    length: number;
+    truck: Channel;
+    pedestal: Channel;
+    dolly: Channel;
+    pan: Channel;
+    tilt: Channel;
+    roll: Channel;
+    zoom: Channel;
+    arc?: Channel;
+    speed: Channel;
+    turn: Channel;
+    acceleration: Channel;
+    jerk: Channel;
+    smoothness: number | null;
+    step: {
+        distance: number;
+        angle: number;
+        at: number;
+    };
+    /** The cuts inside it, times: what is measured stops at each and starts again after. */
+    cuts: number[];
+}
+/** A channel from values at moments: its largest magnitude and when, its mean magnitude. */
+export declare function channel(values: readonly number[], times: readonly number[]): Channel;
+/**
+ * The motion of samples taken at a steady rate. A cut (a time between two
+ * samples) is no motion: the step across it is not measured, and neither
+ * acceleration nor jerk spans it; smoothness is the least smooth shot's.
+ */
+export declare function motionOf(samples: readonly CameraSample[], cuts?: readonly number[]): MotionNumbers;
+//# sourceMappingURL=motion.d.ts.map

package/node_modules/@allyhub-next/scenery/dist/motion.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{distance as V,dot as k,length as L,normalize as N,sub as j}from"./vec.js";const u=a=>Math.round(a*1e6)/1e6;export function channel(a,d){let r=0,m=d[0]??0,g=0;return a.forEach((x,h)=>{const i=Math.abs(x);g+=i,i>r&&(r=i,m=d[h]??m)}),{peak:u(r),at:u(m),mean:u(a.length>0?g/a.length:0)}}const Q=(a,d)=>{let r=d-a;for(;r>180;)r-=360;for(;r<-180;)r+=360;return r},R=(a,d)=>{const r=Math.max(-1,Math.min(1,k(N(a),N(d))));return Math.acos(r)*180/Math.PI};export function motionOf(a,d=[]){const r=a.length,m=[...d].sort((t,n)=>t-n),g=t=>m.filter(n=>n<=t).length,x=m.filter(t=>t>(a[0]?.t??0)&&t<=(a[r-1]?.t??0)),h={peak:0,at:a[0]?.t??0,mean:0};if(r<2)return{length:0,truck:h,pedestal:h,dolly:h,pan:h,tilt:h,roll:h,zoom:h,speed:h,turn:h,acceleration:h,jerk:h,smoothness:null,step:{distance:0,angle:0,at:a[0]?.t??0},cuts:x.map(u)};const i=[],T=[],q=[],B=[],C=[],D=[],F=[],G=[],S=[],_=[],H=[],y=[],M=[];let J=0,f={distance:0,angle:0,at:a[0]?.t??0},K=!0;for(let t=0;t+1<r;t++){const n=a[t],e=a[t+1];if(!n||!e)continue;const o=e.t-n.t;if(!(o>0)||g(n.t)!==g(e.t))continue;const s=j(e.position,n.position),l=[s[0]/o,s[1]/o,s[2]/o];y.push(l),M.push(g(n.t)),i.push((n.t+e.t)/2),T.push(k(l,n.right)),q.push(k(l,n.up)),B.push(k(l,n.forward)),C.push(Q(n.yaw,e.yaw)/o),D.push((e.pitch-n.pitch)/o),F.push(Q(n.roll,e.roll)/o),G.push((Math.log2(e.lens)-Math.log2(n.lens))/o),_.push(L(l));const w=R(n.forward,e.forward);H.push(w/o),n.target&&e.target?S.push(R(j(n.position,n.target),j(e.position,e.target))/o):K=!1;const c=V(n.position,e.position);J+=c,(c>f.distance||w>f.angle)&&(f={distance:Math.max(f.distance,c),angle:Math.max(f.angle,w),at:n.t})}const b=[],z=[],v=[];for(let t=0;t+1<y.length;t++){if(M[t]!==M[t+1])continue;const n=y[t],e=y[t+1],o=i[t],s=i[t+1];if(!n||!e||o===void 0||s===void 0||!(s>o))continue;const l=j(e,n);b.push([l[0]/(s-o),l[1]/(s-o),l[2]/(s-o)]),z.push((o+s)/2),v.push(M[t]??0)}const P=[],E=[],A=[];for(let t=0;t+1<b.length;t++){if(v[t]!==v[t+1])continue;const n=b[t],e=b[t+1],o=z[t],s=z[t+1];if(!n||!e||o===void 0||s===void 0||!(s>o))continue;const l=j(e,n);P.push([l[0]/(s-o),l[1]/(s-o),l[2]/(s-o)]),E.push((o+s)/2),A.push(v[t]??0)}let O=null;for(const t of new Set(A)){const n=P.filter((c,p)=>A[p]===t),e=E.filter((c,p)=>A[p]===t),o=a.filter(c=>g(c.t)===t).map(c=>c.t),s=Math.max(0,..._.filter((c,p)=>M[p]===t));if(!(s>1e-9)||n.length<2)continue;let l=0;for(let c=0;c+1<n.length;c++){const p=n[c],I=n[c+1],U=(e[c+1]??0)-(e[c]??0);!p||!I||(l+=(k(p,p)+k(I,I))/2*U)}const w=(o.at(-1)??0)-(o[0]??0);if(l>0){const c=u(-Math.log(w**3/(s*s)*l));(O===null||c<O)&&(O=c)}}return{length:u(J),truck:channel(T,i),pedestal:channel(q,i),dolly:channel(B,i),pan:channel(C,i),tilt:channel(D,i),roll:channel(F,i),zoom:channel(G,i),...K&&S.length>0?{arc:channel(S,i)}:{},speed:channel(_,i),turn:channel(H,i),acceleration:channel(b.map(L),z),jerk:channel(P.map(L),E),smoothness:O,step:{distance:u(f.distance),angle:u(f.angle),at:u(f.at)},cuts:x.map(u)}}

package/node_modules/@allyhub-next/scenery/dist/move.d.ts

@@ -0,0 +1,260 @@
+import { type CameraState } from "./camera.js";
+import { Curve } from "./curve.js";
+import type { LensFrame } from "./lens.js";
+import { type Ease } from "./timing.js";
+import { type Vec3 } from "./vec.js";
+/** What a move may ask of the scenery at its moment. */
+export interface SceneryView {
+    /** Where a named object is now (the centre of its box), or undefined. */
+    pointOf(name: string): Vec3 | undefined;
+    /**
+     * The scenery time, s, of a word or anchor reference ("@turn", "@turn+0.2",
+     * a word): there where the scenery is drawn in a part, from that part's
+     * speech and anchors, or where its host was given the times. Undefined
+     * elsewhere.
+     */
+    time?: (ref: string) => number;
+    /** The frame's width over height, where the camera is drawn for one. */
+    aspect?: number;
+    /** A screen's face (an object's first mesh, its +Z side), as it is now; undefined for no such object. */
+    screen?: (name: string) => ScreenFace | undefined;
+}
+/**
+ * A screen's face in the scenery: a point of it from its content's top left
+ * (x, y as shares of its width and height), the way it faces, its up, and
+ * its size in metres.
+ */
+export interface ScreenFace {
+    point(x: number, y: number): Vec3;
+    center: Vec3;
+    normal: Vec3;
+    up: Vec3;
+    width: number;
+    height: number;
+}
+/**
+ * A move's moment written as a word or anchor reference, asked for where
+ * the scenery has no times (no part shows it, and its host was given
+ * none). A host that can be given times catches it to say how.
+ */
+export declare class NeedsTimeError extends Error {
+    /** The reference, as written. */
+    readonly ref: string;
+    /** What the reference was given as ("A shot's from", "keys()' t"). */
+    readonly what: string;
+    constructor(ref: string, what: string);
+}
+/**
+ * A moment a move is written with: seconds of scenery time, or a word or
+ * anchor reference of the part that shows the scenery (SceneryView.time).
+ */
+export type MoveTime = number | string;
+/**
+ * A camera as a function of scenery time. A move made by shots() also says
+ * where it cuts (`cuts`, read with cutsOf), so no measurement of motion
+ * spans a cut.
+ */
+export interface Move {
+    (t: number, scenery?: SceneryView): CameraState;
+    /** Its cuts, s of scenery time: fixed, or found from the scenery's reference times. */
+    readonly cuts?: Cuts;
+}
+/** Where a move cuts: scenery times, or a function of the scenery that finds them. */
+export type Cuts = readonly number[] | ((scenery?: SceneryView) => readonly number[]);
+/** What every move passes on to the camera it returns. */
+export interface LensOptions {
+    /** 35 mm-equivalent focal length, mm (CameraState.lens). */
+    lens?: number;
+    lensFrame?: LensFrame;
+    /** Vertical degrees, instead of a lens. */
+    fov?: number;
+    roll?: number;
+    up?: Vec3;
+    near?: number;
+    far?: number;
+    /** The f-number (CameraState.aperture). */
+    aperture?: number;
+    /** Where it focuses (CameraState.focus). */
+    focus?: number | Vec3 | string;
+    /** Its exposure, EV at ISO 100 (CameraState.ev). */
+    ev?: number;
+}
+/** A camera key: a moment and what the camera is then. Channels a key leaves out are interpolated from the keys that have them. */
+export interface CameraKey {
+    /** Seconds of scenery time, or a word or anchor reference of the part that shows the scenery ("@turn"). */
+    t: MoveTime;
+    position?: Vec3;
+    /** A point, or an object's name. */
+    target?: Vec3 | string;
+    yaw?: number;
+    pitch?: number;
+    lens?: number;
+    fov?: number;
+    roll?: number;
+    /** The f-number (CameraState.aperture), passed on a log scale: every key or none. */
+    aperture?: number;
+    /** Its exposure, EV at ISO 100 (CameraState.ev), passed straight: every key or none. */
+    ev?: number;
+    /**
+     * Where it focuses (CameraState.focus): distances pass in dioptres (one
+     * over the distance), as a focus is pulled; points move like the
+     * position; names are blended stretch by stretch, as targets are.
+     */
+    focus?: number | Vec3 | string;
+    /** How the stretch arriving at this key runs, in every channel; breaks the speed at its ends. */
+    ease?: Ease;
+}
+export interface KeysOptions extends LensOptions {
+    /**
+     * How a lens changes between keys: "log" (default), in log focal
+     * length, so a zoom changes size at a constant ratio; "fov", in degrees
+     * of field of view.
+     */
+    lensSpace?: "log" | "fov";
+}
+/**
+ * A camera through keyframes. Position passes each key at its time along a
+ * curve through the keys, at a speed continuous across keys (except at a
+ * key with an ease); a key that repeats the last position holds. Targets
+ * that are points move the same way; targets that are names are found in
+ * the scenery at each moment and blended stretch by stretch. Lens, fov,
+ * roll, yaw and pitch pass their keys on monotone cubics.
+ */
+export declare function keys(list: readonly CameraKey[], opts?: KeysOptions): Move;
+export interface PathOptions extends LensOptions {
+    /** When the camera leaves the first point: s of scenery time, or a word or anchor reference; default 0. */
+    start?: MoveTime;
+    /** How long it takes to reach the last point, s. Give this or speed. */
+    dur?: number;
+    /** Its speed, m/s. Give this or dur. */
+    speed?: number;
+    /** How the distance travelled runs over the time; default "linear" (constant speed). */
+    ease?: Ease;
+    /** Where it looks: a point, an object's name, or "ahead" (the default), along the path. */
+    target?: Vec3 | string;
+    /** With target "ahead": how far on along the path it looks, m; default 1. */
+    ahead?: number;
+    /**
+     * Which way is up: "scenery" (the default) keeps `up`; "rmf" carries it
+     * along the path in a frame that does not twist about it.
+     */
+    frame?: "scenery" | "rmf";
+    /** Curve tension: 0.5 centripetal (the default), 0 uniform, 1 chordal. */
+    alpha?: number;
+}
+export declare const PATH_DEFAULTS: {
+    start: number;
+    ahead: number;
+    alpha: number;
+};
+/** A camera moving along a curve through points at constant speed (or an ease on the distance). */
+export declare function path(points: readonly Vec3[], opts: PathOptions): Move;
+/** The curve a path() follows, for measuring it: its length and points along it. */
+export declare function pathCurve(points: readonly Vec3[], alpha?: number): Curve;
+export interface OrbitOptions extends LensOptions {
+    /** The point or the object's name it goes round. */
+    around: Vec3 | string;
+    /** Distance from the centre on the floor's plane, m. */
+    radius: number;
+    /** Height above the centre, m; default 0. */
+    height?: number;
+    /**
+     * Angles in degrees: 0 on the centre's +Z side (in front of a model that
+     * faces +Z), 90 on its +X side; counterclockwise seen from above. Not
+     * wrapped: 0 → 540 goes round one and a half times.
+     */
+    from: number;
+    to: number;
+    /** When it starts: s of scenery time, or a word or anchor reference; default 0. */
+    start?: MoveTime;
+    /** How long it takes, s. */
+    dur: number;
+    /** How the angle runs over the time; default "linear". */
+    ease?: Ease;
+    /** Where it looks; default the centre. */
+    target?: Vec3 | string;
+}
+/** A camera going round a point at a radius and height. */
+export declare function orbit(opts: OrbitOptions): Move;
+/** One shot of shots(): when it starts, and the camera it holds or the move it makes. */
+export interface Shot {
+    /** Seconds of scenery time, or a word or anchor reference of the part. The first shot also holds before its start. */
+    from: MoveTime;
+    /** A camera that holds still, or a move (keys, path, orbit, your own), in scenery time. */
+    camera: CameraState | Move;
+}
+/**
+ * A camera made of shots joined by cuts, as a film is: each shot from its
+ * start until the next one's, a still camera or a move of its own; at each
+ * start the picture cuts. A pause before a cut is a shot that holds. The
+ * measurements of motion stop at each cut (cutsOf).
+ */
+export declare function shots(list: readonly Shot[]): Move;
+/** The cuts of a camera made by shots(), scenery times (none for any other camera, or one wrapped in a function of yours). */
+export declare function cutsOf(camera: CameraState | Move, scenery?: SceneryView): number[];
+/**
+ * `move` with the cuts of `camera` (a camera made by shots()), so a move
+ * of yours wrapped round it keeps them for the measurements; returns
+ * `move`.
+ */
+export declare function withCuts(camera: CameraState | Move, move: (t: number, scenery?: SceneryView) => CameraState): Move;
+export interface FocusScreenOptions {
+    /** How far toward the frame's edges the rectangle may reach, 0–1 (fitCamera's fill); default 1. */
+    fill?: number;
+    /** The lens (35 mm-equivalent), or a vertical fov in degrees; default the camera default's. */
+    lens?: number;
+    fov?: number;
+    /**
+     * Degrees off looking at the screen square on, default 0: `yaw` turns
+     * about the screen's up (positive: the camera to the right of someone
+     * facing the screen, looking left at it), then `pitch` up or down
+     * (positive: below the screen, looking up, as a camera's pitch looks up).
+     */
+    yaw?: number;
+    pitch?: number;
+    /** The frame's width over height; default the scenery layer's. */
+    aspect?: number;
+    /** Its exposure, EV at ISO 100 (CameraState.ev). */
+    ev?: number;
+    /** What `lens` is measured on (CameraState.lensFrame): "phone" for a phone's own "26 mm". */
+    lensFrame?: LensFrame;
+}
+/**
+ * A camera framing a rectangle of a screen's content exactly: `rect` is
+ * [x, y, width, height] as shares of the content (from its top left: a
+ * button at px [1200, 80, 160, 48] of 1920 × 1200 is [0.625, 0.067,
+ * 0.083, 0.04]), seen square on (or `yaw`/`pitch` off it), the screen's up
+ * kept up. A camera of the scenery's, so the room is framed with it.
+ */
+export declare function focusScreen(screen: string, rect: readonly [number, number, number, number], opts?: FocusScreenOptions): Move;
+/** A camera, or a move's camera at `t`. */
+export declare const stateOf: (c: CameraState | Move, t: number, scenery?: SceneryView) => CameraState;
+/**
+ * The camera `x` of the way from `sa` to `sb` (past 1 or under 0 goes on
+ * past them): its position, its view and its up, its lens at a constant
+ * zoom ratio, its depth of field (the aperture's area and the focus in
+ * dioptres), its exposure in stops. `xEv`, when given, is the exposure's
+ * own share of the way. `what` names the caller in its errors.
+ */
+export declare function mixCameras(sa: CameraState, sb: CameraState, x: number, scenery: SceneryView | undefined, what: string, xEv?: number): CameraState;
+/** A move's moment: seconds, or a reference's scenery time (or why it has none). */
+export declare function momentOf(scenery: SceneryView | undefined, at: MoveTime, what: string): number;
+export interface BlendOptions {
+    /** When it leaves the first camera, and when it is the second: seconds of scenery time or references. */
+    from: MoveTime;
+    to: MoveTime;
+    /**
+     * How it runs between them; default "smooth" (still at both ends, at
+     * one and a half times its mean speed half way).
+     */
+    ease?: Ease;
+}
+/**
+ * From one camera to another over a stretch of time: the first before
+ * `from`, the second after `to`, and between them its position, its
+ * view, its up and its lens on their way from one to the other (the lens
+ * at a constant zoom ratio). A push in to a screen and a pull back out are
+ * blends; each camera may itself move.
+ */
+export declare function blend(a: CameraState | Move, b: CameraState | Move, opts: BlendOptions): Move;
+//# sourceMappingURL=move.d.ts.map

package/node_modules/@allyhub-next/scenery/dist/move.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{resolveCamera as R}from"./camera.js";import{Curve as V,SAME_POINT as X}from"./curve.js";import{easeValue as O,timedNumber as Y}from"./timing.js";import{fitCamera as fe}from"./fit.js";import{cross as Z,distance as ee,dot as ue,lerp3 as T,normalize as _,scale as ce}from"./vec.js";export class NeedsTimeError extends Error{ref;what;constructor(n,t){super(`${t} "${n}" is a word or anchor reference: it has a time only in a part that shows the scenery, or where the scenery's host is given the times.`),this.name="NeedsTimeError",this.ref=n,this.what=t}}function b(e,n,t){if(!e?.time)throw new NeedsTimeError(n,t);const a=e.time(n);if(!Number.isFinite(a))throw new Error(`${t} "${n}" has no time (${String(a)}).`);return a}function z(e,n,t){const a=new WeakMap;return(f,o)=>{const u=e[0]??"";b(o,u,n);const c=o.time;let r=a.get(c);return r||(r=t(i=>b(o,i,n)),a.set(c,r)),r(f,o)}}const D=(e,n)=>Object.assign(e,{cuts:n}),L=e=>({...e.lens!==void 0?{lens:e.lens}:{},...e.lensFrame!==void 0?{lensFrame:e.lensFrame}:{},...e.fov!==void 0?{fov:e.fov}:{},...e.roll!==void 0?{roll:e.roll}:{},...e.up!==void 0?{up:e.up}:{},...e.near!==void 0?{near:e.near}:{},...e.far!==void 0?{far:e.far}:{},...e.aperture!==void 0?{aperture:e.aperture}:{},...e.focus!==void 0?{focus:e.focus}:{},...e.ev!==void 0?{ev:e.ev}:{}});function I(e,n,t){if(typeof e!="string")return e;const a=n?.pointOf(e);if(!a)throw new Error(n?`${t} "${e}" names nothing in the scenery.`:`${t} "${e}" is a name, and the move was not given the scenery to find it in.`);return a}function W(e){const n=e[0];if(!n)throw new Error("A point over time needs at least one key.");const t=[],a=[0];let f=0,o=0;for(;o+1<e.length;){if(ee(e[o]?.v??n.v,e[o+1]?.v??n.v)<=X){a.push(f),o++;continue}let r=o+1;for(;r+1<e.length&&ee(e[r]?.v??n.v,e[r+1]?.v??n.v)>X;)r++;const i=new V(e.slice(o,r+1).map(d=>d.v));t.push({from:o,to:r,curve:i,start:f});for(let d=o+1;d<=r;d++)a.push(f+(i.knots[d-o]??0));f+=i.length,o=r}const u=Y(e.map((r,i)=>({t:r.t,v:a[i]??0,...r.ease!==void 0?{ease:r.ease}:{}}))),c=e.at(-1)??n;return r=>{if(!(r>n.t))return n.v;if(r>=c.t)return c.v;let i=0;for(;i+1<e.length&&(e[i+1]?.t??1/0)<=r;)i++;const d=t.find(h=>i>=h.from&&i<h.to);return d?d.curve.at(u(r)-d.start).point:e[i]?.v??n.v}}function E(e,n){const t=[];for(const a of e){const f=n(a);f!==void 0&&t.push({t:a.t,v:f,...a.ease!==void 0?{ease:a.ease}:{}})}return t}export function keys(e,n={}){if(e.length===0)throw new Error("keys() needs at least one key.");const t=e.flatMap(a=>typeof a.t=="string"?[a.t]:[]);return t.length===0?re(e,n):(te(e),z(t,"A key's t",a=>{const f=e.map(o=>({...o,t:typeof o.t=="string"?a(o.t):o.t}));return f.forEach((o,u)=>{const c=f[u-1];if(c&&!(o.t>c.t)){const r=(i,d)=>typeof i.t=="string"?`"${i.t}" (${d.toFixed(3)} s)`:`${d.toFixed(3)} s`;throw new Error(`Keys must be in time order: the key at ${r(e[u]??o,o.t)} does not come after the one at ${r(e[u-1]??c,c.t)}.`)}}),re(f,n)}))}const ne=e=>typeof e.t=="string"?`"${e.t}"`:`${String(e.t)} s`;function te(e){for(const n of e){if(typeof n.t=="number"&&!Number.isFinite(n.t))throw new Error(`A key's t must be a number of seconds or a reference, not ${String(n.t)}.`);if(typeof n.t=="string"&&n.t.trim()==="")throw new Error("A key's t is an empty reference.");if(n.target!==void 0&&(n.yaw!==void 0||n.pitch!==void 0))throw new Error(`The key at ${ne(n)} points two ways (a target and yaw/pitch): give one.`);if(n.lens!==void 0&&n.fov!==void 0)throw new Error(`The key at ${ne(n)} has both a lens and a fov: give one.`)}}function re(e,n){te(e);const t=E(e,s=>s.position);if(t.length===0)throw new Error("keys() needs a position in at least one key.");const a=W(t),f=E(e,s=>s.target),o=e.some(s=>s.yaw!==void 0||s.pitch!==void 0);if(f.length>0&&o)throw new Error("keys() points by target in some keys and by yaw/pitch in others: use one way throughout.");const u=f.some(s=>typeof s.v=="string"),c=f.length>0&&!u?W(f.map(s=>({...s,v:s.v}))):void 0,r=f[0],i=u&&f.every(s=>s.v===r?.v)?r?.v:void 0,d=(s,$)=>{const g=E(e,s);return g.length===0?void 0:Y(g.map(A=>({...A,v:$?$(A.v):A.v})))},h=E(e,s=>s.lens),m=E(e,s=>s.fov);if(h.length>0&&m.length>0)throw new Error("keys() sets a lens in some keys and a fov in others: use one throughout.");const M=(n.lensSpace??"log")==="log",P=d(s=>s.lens,M?Math.log:void 0),S=d(s=>s.fov),F=d(s=>s.roll),K=d(s=>s.yaw),N=d(s=>s.pitch),H=E(e,s=>s.aperture);if(H.length>0&&H.length<e.length)throw new Error("keys() gives an aperture in some keys and not in others: give it in every key, or in none (a pinhole is no aperture).");const se=d(s=>s.aperture,Math.log),J=E(e,s=>s.ev);if(J.length>0&&J.length<e.length)throw new Error("keys() gives an ev in some keys and not in others: give it in every key, or in none (the scenery's own exposure).");const ie=d(s=>s.ev),w=E(e,s=>s.focus),C=new Set(w.map(s=>typeof s.v=="number"?"distance":typeof s.v=="string"?"name":"point"));if(C.has("distance")&&C.size>1)throw new Error("keys() focuses by distance in some keys and on a point or an object in others: use one way throughout.");const j=C.has("distance")?d(s=>typeof s.focus=="number"?s.focus:void 0,s=>1/s):void 0,U=C.has("name"),q=w.length>0&&!U&&!j?W(w.map(s=>({...s,v:s.v}))):void 0;return(s,$)=>{let g;if(c)g=c(s);else if(i!==void 0)g=i;else if(u&&r){const p=f.at(-1)??r;if(!(s>r.t))g=r.v;else if(s>=p.t)g=p.v;else{let v=0;for(;v+1<f.length&&(f[v+1]?.t??1/0)<=s;)v++;const l=f[v]??r,x=f[v+1]??p,k=O(x.ease??"in-out",(s-l.t)/(x.t-l.t));g=T(I(l.v,$,"A key's target"),I(x.v,$,"A key's target"),k)}}const A=P?.(s);let y;if(j)y=1/j(s);else if(q)y=q(s);else if(U){const p=w[0],v=w.at(-1);if(p&&v)if(w.every(l=>l.v===p.v))y=p.v;else if(!(s>p.t))y=p.v;else if(s>=v.t)y=v.v;else{let l=0;for(;l+1<w.length&&(w[l+1]?.t??1/0)<=s;)l++;const x=w[l]??p,k=w[l+1]??v,ae=O(k.ease??"in-out",(s-x.t)/(k.t-x.t));y=T(I(x.v,$,"A key's focus"),I(k.v,$,"A key's focus"),ae)}}const G=se?.(s),Q=ie?.(s);return{...L(n),...Q!==void 0?{ev:Q}:{},...G!==void 0?{aperture:Math.exp(G)}:{},...y!==void 0?{focus:y}:{},position:a(s),...g!==void 0?{target:g}:{},...K?{yaw:K(s)}:{},...N?{pitch:N(s)}:{},...A!==void 0?{lens:M?Math.exp(A):A}:{},...S?{fov:S(s)}:{},...F?{roll:F(s)}:{}}}}export const PATH_DEFAULTS={start:0,ahead:1,alpha:.5};export function path(e,n){if(e.length===0)throw new Error("path() needs at least one point.");const t=n.start??PATH_DEFAULTS.start;return typeof t=="string"?(B(e,{...n,start:0}),z([t],"path()'s start",a=>B(e,{...n,start:a(t)}))):B(e,{...n,start:t})}function B(e,n){if(n.dur===void 0==(n.speed===void 0))throw new Error("path() needs dur (seconds) or speed (m/s): give one.");const t=new V(e,n.alpha??PATH_DEFAULTS.alpha),a=n.dur??t.length/(n.speed??1);if(!(Number.isFinite(a)&&a>=0))throw new Error(`path()'s duration ${String(a)} s is not a number of seconds.`);const f=n.start,o=n.ahead??PATH_DEFAULTS.ahead,u=n.target??"ahead";return c=>{const r=a>0?(c-f)/a:c>=f?1:0,i=t.length*O(n.ease,r),d=t.at(i),h={...L(n),position:d.point,target:u==="ahead"?t.extended(i+o):u};return n.frame==="rmf"&&(h.up=t.upAt(i,n.up)),h}}export function pathCurve(e,n=PATH_DEFAULTS.alpha){return new V(e,n)}export function orbit(e){if(!(Number.isFinite(e.radius)&&e.radius>=0))throw new Error(`orbit()'s radius ${String(e.radius)} is not a distance.`);if(!(Number.isFinite(e.dur)&&e.dur>=0))throw new Error(`orbit()'s dur ${String(e.dur)} is not a number of seconds.`);return(n,t)=>{const a=typeof e.start=="string"?b(t,e.start,"orbit()'s start"):e.start??0,f=I(e.around,t,"orbit()'s centre"),o=e.dur>0?(n-a)/e.dur:n>=a?1:0,u=(e.from+(e.to-e.from)*O(e.ease,o))*Math.PI/180;return{...L(e),position:[f[0]+e.radius*Math.sin(u),f[1]+(e.height??0),f[2]+e.radius*Math.cos(u)],target:e.target??f}}}export function shots(e){if(e.length===0)throw new Error("shots() needs at least one shot.");for(const o of e){if(typeof o.from=="number"&&!Number.isFinite(o.from))throw new Error(`A shot's from must be seconds or a reference, not ${String(o.from)}.`);if(typeof o.camera!="function"&&!Array.isArray(o.camera.position))throw new Error("A shot's camera is a camera state or a move.")}const n=e.flatMap(o=>typeof o.from=="string"?[o.from]:[]),t=o=>{const u=e.map(c=>typeof c.from=="number"?c.from:o?o(c.from):b(void 0,c.from,"A shot's from"));return u.forEach((c,r)=>{const i=u[r-1];if(i!==void 0&&!(c>i)){const d=h=>{const m=e[h]?.from;return typeof m=="string"?`"${m}"`:`${String(m)} s`};throw new Error(`Shots must be in time order: the shot from ${d(r)} (${c.toFixed(3)} s) does not come after the one from ${d(r-1)} (${i.toFixed(3)} s).`)}}),u},a=o=>D((u,c)=>{let r=0;for(;r+1<o.length&&(o[r+1]??1/0)<=u;)r++;const i=e[r]?.camera;if(i===void 0)throw new Error("No shot.");return typeof i=="function"?i(u,c):i},o.slice(1));if(n.length===0)return a(t(void 0));const f=new WeakMap;return D((o,u)=>{b(u,n[0]??"","A shot's from");const c=u.time;let r=f.get(c);return r||(r=a(t(i=>b(u,i,"A shot's from"))),f.set(c,r)),r(o,u)},o=>o?.time?t(u=>b(o,u,"A shot's from")).slice(1):[])}export function cutsOf(e,n){if(typeof e!="function")return[];const t=e.cuts;return t===void 0?[]:typeof t=="function"?[...t(n)]:[...t]}export function withCuts(e,n){const t=typeof e=="function"?e.cuts:void 0;return t===void 0?n:D(n,t)}function oe(e,n,t){const a=t*Math.PI/180,f=Math.cos(a),o=Math.sin(a),u=_(n),c=Z(u,e),r=ue(u,e)*(1-f);return[e[0]*f+c[0]*o+u[0]*r,e[1]*f+c[1]*o+u[1]*r,e[2]*f+c[2]*o+u[2]*r]}export function focusScreen(e,n,t={}){const[a,f,o,u]=n;if(![a,f,o,u].every(c=>Number.isFinite(c))||!(o>0&&u>0))throw new Error(`focusScreen()'s rect is [x, y, width, height] as shares of the screen's content, not ${JSON.stringify(n)}.`);return(c,r)=>{const i=r?.screen?.(e);if(!i)throw new Error(r?.screen?`focusScreen(): the scenery has no screen "${e}" (an object with a mesh).`:"focusScreen() needs the scenery it is drawn in.");const d=t.aspect??r?.aspect;if(d===void 0)throw new Error("focusScreen() needs the frame's aspect: a scenery layer gives it; elsewhere pass aspect.");let h=ce(i.normal,-1);t.yaw&&(h=oe(h,i.up,t.yaw)),t.pitch&&(h=oe(h,Z(h,i.up),t.pitch));const m=fe({points:[i.point(a,f),i.point(a+o,f),i.point(a+o,f+u),i.point(a,f+u)],direction:h,up:i.up,aspect:d,...t.lens!==void 0?{lens:t.lens}:{},...t.lensFrame!==void 0?{lensFrame:t.lensFrame}:{},...t.fov!==void 0?{fov:t.fov}:{},...t.fill!==void 0?{fill:t.fill}:{}});return t.ev!==void 0?{...m,ev:t.ev}:m}}export const stateOf=(e,n,t)=>typeof e=="function"?e(n,t):e;export function mixCameras(e,n,t,a,f,o=t){const u=a?.aspect??1,c=M=>a?.pointOf(M),r=R(e,u,c),i=R(n,u,c);if(r.ev===void 0!=(i.ev===void 0))throw new Error(`${f} goes between a camera with an ev and one without: give both an ev, or neither (the scenery's own exposure).`);const d=r.dof,h=i.dof;let m;if(d||h){const M=d?d.aperture*(r.lens/d.lens):1/0,P=h?h.aperture*(i.lens/h.lens):1/0,S=1/M*(1-t)+1/P*t,F=d?.focus??h?.focus??1,K=h?.focus??F,N=1/F*(1-t)+1/K*t;S>0&&N>0&&(m={aperture:1/S,focus:1/N})}return{position:T(r.position,i.position,t),direction:_(T(r.forward,i.forward,t)),up:_(T(r.up,i.up,t)),lens:Math.exp(Math.log(r.lens)+(Math.log(i.lens)-Math.log(r.lens))*t),near:Math.min(r.near,i.near),far:Math.max(r.far,i.far),...m??{},...r.ev!==void 0&&i.ev!==void 0?{ev:r.ev*(1-o)+i.ev*o}:{}}}export function momentOf(e,n,t){return typeof n=="number"?n:b(e,n,t)}export function blend(e,n,t){const a=(o,u)=>{if(!(u>o))throw new Error(`blend()'s to (${String(u)} s) must come after its from (${String(o)} s).`);return(c,r)=>{if(c<=o)return stateOf(e,c,r);if(c>=u)return stateOf(n,c,r);const i=O(t.ease??"smooth",(c-o)/(u-o));return mixCameras(stateOf(e,c,r),stateOf(n,c,r),i,r,"blend()")}},f=[t.from,t.to].filter(o=>typeof o=="string");return f.length===0?a(t.from,t.to):z(f,"blend()'s from or to",o=>a(typeof t.from=="string"?o(t.from):t.from,typeof t.to=="string"?o(t.to):t.to))}

package/node_modules/@allyhub-next/scenery/dist/noise.d.ts

@@ -0,0 +1,41 @@
+/** A band of frequencies: its centre and its spread (the spectrum's standard deviation), Hz. */
+export interface Band {
+    /** Hz; 0 for low-pass noise. */
+    center: number;
+    /** Hz, above 0: how far the spectrum spreads either side of the centre. */
+    spread: number;
+}
+/** A hash of three whole numbers, 0 to 2³² − 1. */
+export declare function hash3(a: number, b: number, c: number): number;
+/** A number from 0 to 1 (never 0 or 1) for three whole numbers. */
+export declare function unit3(a: number, b: number, c: number): number;
+/** A standard normal number for three whole numbers (Box–Muller). */
+export declare function gauss3(a: number, b: number, c: number): number;
+/**
+ * Noise of standard deviation 1 (in expectation) whose spectrum is a
+ * Gaussian bump of `band.spread` Hz round `band.center` (and round 0 for
+ * a centre of 0): a lattice of seeded normal numbers, filtered by a Gabor
+ * kernel. Each `channel` of a seed is another noise.
+ */
+export declare function bandNoise(seed: number, channel: number, band: Band): (t: number) => number;
+/** A power-law spectrum: its power density falls as 1/f^alpha from `low` to `high` Hz. */
+export interface Slope {
+    low: number;
+    high: number;
+    /** 0 is white, 1 pink, 2 brown (a hand's sway is near 2). */
+    alpha: number;
+}
+/**
+ * Noise of standard deviation 1 whose spectrum falls as 1/f^alpha between
+ * `low` and `high` Hz: half-octave bands, each with its share of the
+ * power. Each `channel` is another noise. `gain`, by a band's centre,
+ * takes part of it out (a stabiliser): the deviation is then less than 1.
+ */
+export declare function powerNoise(seed: number, channel: number, slope: Slope, gain?: (center: number) => number): (t: number) => number;
+/**
+ * A gain that waxes and wanes about 1 (exp(β·g − β²) over low-pass noise
+ * g), so that what it multiplies keeps its standard deviation in
+ * expectation: `swell` is β, `period` the seconds of its slow swing.
+ */
+export declare function swellOf(seed: number, channel: number, swell: number, period: number): (t: number) => number;
+//# sourceMappingURL=noise.d.ts.map

package/node_modules/@allyhub-next/scenery/dist/noise.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+function b(e){let t=e|0;return t^=t>>>16,t=Math.imul(t,2246822507),t^=t>>>13,t=Math.imul(t,3266489909),t^=t>>>16,t>>>0}export function hash3(e,t,n){return b(b(b(e^2654435769)^Math.imul(t|0,1663821227))^Math.imul(n|0,668265263))}export function unit3(e,t,n){return(hash3(e,t,n)+.5)/4294967296}export function gauss3(e,t,n){const a=unit3(e,t,n),s=unit3(e^1540483477,n,t);return Math.sqrt(-2*Math.log(a))*Math.cos(2*Math.PI*s)}const I=4;export function bandNoise(e,t,n){const a=Math.max(0,n.center),s=Math.max(1e-6,n.spread),r=1/(2*Math.PI*s),h=2.5*(a+I*s),M=1/h,f=h*(Math.sqrt(Math.PI)*r/2)*(1+Math.exp(-4*Math.PI*Math.PI*a*a*r*r)),i=1/Math.sqrt(f),u=I*r,m=e|0,l=t|0;return o=>{if(!Number.isFinite(o))return 0;const c=Math.ceil((o-u)*h),x=Math.floor((o+u)*h);let g=0;for(let p=c;p<=x;p++){const d=o-p*M,P=Math.exp(-d*d/(2*r*r));g+=gauss3(m,l,p)*P*(a>0?Math.cos(2*Math.PI*a*d):1)}return g*i}}export function powerNoise(e,t,n,a=()=>1){const{low:s,high:r,alpha:h}=n,M=Math.max(1,Math.round(2*Math.log2(Math.max(r/s,1)))),f=(r/s)**(1/M),i=Array.from({length:M},(o,c)=>s*f**(c+.5)),u=i.map(o=>o**(1-h)),m=u.reduce((o,c)=>o+c,0),l=i.map((o,c)=>({noise:bandNoise(e,t*64+c,{center:o,spread:o*.2}),k:a(o)*Math.sqrt((u[c]??0)/m)}));return o=>l.reduce((c,x)=>c+x.k*x.noise(o),0)}export function swellOf(e,t,n,a){if(n<=0)return()=>1;const s=bandNoise(e,t,{center:0,spread:1/a});return r=>Math.exp(n*s(r)-n*n)}