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

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)}

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

@@ -0,0 +1,34 @@
+import type { HandheldOptions } from "./handheld.js";
+import type { LensFrame } from "./lens.js";
+import type { SensorOptions } from "./moire.js";
+/** What a phone's camera is, as the options of each mechanism. */
+export interface PhoneCamera {
+    /** A camera state's lens: 35 mm-equivalent focal length on the phone's 4:3 frame, and its aperture in the same terms. */
+    lens: {
+        lens: number;
+        lensFrame: LensFrame;
+        aperture: number;
+    };
+    /** The sensor filming a screen: its photosites, the lens's own blur on them, its moiré and false colour, its distortion. */
+    sensor: SensorOptions;
+    /** handheld(camera, hand): the hand, its stabiliser, its autofocus and auto-exposure. */
+    hand: HandheldOptions;
+}
+/**
+ * A phone's main camera filming a screen or a room indoors, held in a
+ * hand: a 26 mm lens on its 4:3 frame at f/8 equivalent (f/1.8 on its
+ * small sensor), a 12 MP sensor, a hand whose tremor its stabiliser mostly
+ * takes out, focus that hunts after a cut, a reframe or a jolt, exposure
+ * that follows a new framing late.
+ */
+export declare const PHONE_CAMERA: PhoneCamera;
+/** Something with every field optional, all the way down. */
+export type Deeper<T> = {
+    [K in keyof T]?: T[K] extends readonly unknown[] ? T[K] : T[K] extends object ? Deeper<T[K]> : T[K];
+};
+/**
+ * PHONE_CAMERA with any of its values changed (`{ hand: { tremor: { angle:
+ * 0.2 } } }` changes that one and keeps the rest).
+ */
+export declare function phoneCamera(over?: Deeper<PhoneCamera>): PhoneCamera;
+//# sourceMappingURL=phone.d.ts.map

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

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export const PHONE_CAMERA={lens:{lens:26,lensFrame:"phone",aperture:8},sensor:{photosites:4032,lens:.35,moire:1,chroma:.3,distortion:-.03},hand:{angle:.25,roll:.6,shift:.001,sway:.65,tremor:{angle:.1,frequency:8.5},drift:{angle:.15,shift:.001,period:8},stabilizer:{strength:.7,cutoff:1.5},autofocus:{},exposure:{}}};const s=e=>typeof e=="object"&&e!==null&&!Array.isArray(e);function i(e,n){if(!s(e)||!s(n))return n===void 0?e:n;const t={...e};for(const[r,o]of Object.entries(n))t[r]=o===void 0?e[r]:i(e[r],o);return t}export function phoneCamera(e={}){return i(PHONE_CAMERA,e)}