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

package/node_modules/@allyhub-next/scenery/LICENSE

@@ -0,0 +1,241 @@
+AllyHub Software License
+
+Copyright (c) 2026 AllyHub, Inc. ("AllyHub"). All rights reserved.
+
+This software (the AllyHub command-line tool, its SDK, runtime and the
+packages they depend on) is proprietary. It is not open source.
+
+1. Permitted use. You may install and run the software, unmodified, to make,
+   check, preview and render videos and decks, including for commercial
+   purposes. What you make with it is yours.
+
+2. Restrictions. Except as this license permits or applicable law requires,
+   you may not copy, modify, adapt, translate, sublicense, sell, rent, lease,
+   publish or otherwise distribute the software, create derivative works of
+   it, or reverse engineer, decompile or disassemble it.
+
+3. Cloud services. AllyHub's cloud tools (sign-in, research, images, voice,
+   video) are separate services governed by AllyHub's terms of service.
+
+4. Trademarks. This license grants no right to use the name "AllyHub" or its
+   logos.
+
+5. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+   KIND, EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+   ALLYHUB BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.
+
+6. Third-party code. Parts of the software are adapted from HyperFrames,
+   licensed under the Apache License, Version 2.0 (see NOTICE). Those parts
+   remain under that license, reproduced below, and nothing in this license
+   limits your rights under it.
+
+7. Starter components. The starter components in the "components" folder,
+   which "allyhub add" copies into your workspace, are licensed under the MIT
+   License (see components/LICENSE): once copied, you may change, use and
+   share them freely.
+
+--------------------------------------------------------------------------------
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/node_modules/@allyhub-next/scenery/NOTICE

@@ -0,0 +1,42 @@
+AllyHub
+Copyright (c) 2026 AllyHub, Inc. All rights reserved.
+
+This product is proprietary; see LICENSE.
+
+The centripetal Catmull-Rom tangents in src/curve.ts follow three.js's
+CatmullRomCurve3 (src/extras/curves/CatmullRomCurve3.js)
+(https://github.com/mrdoob/three.js),
+Copyright 2010-2026 three.js authors, under the MIT License:
+
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to permit
+  persons to whom the Software is furnished to do so, subject to the
+  following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+  NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+  OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+  USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+The arc-length parametrisation (Gauss-Legendre quadrature per segment,
+inverted by Newton steps with a bisection fallback) and the timing of
+keyframes by a monotone cubic follow the approach of the splines library
+(https://github.com/AudioSceneDescriptionFormat/splines), Copyright (c)
+2018-2026 Matthias Geier, under the MIT License (the same terms as above).
+No code of it is copied.
+
+The moiré a sensor makes of a screen (src/moire.ts) follows
+the screen-capture simulation of UniDemoiré
+(https://github.com/4DVLab/UniDemoire, unidemoire/models/shooting), Copyright
+(c) 2024 4DVLab, under the MIT License: a screen's RGB subpixels, the
+projective transform, the sensor's Bayer filter. It is worked out in closed
+form per pixel; no code of it is copied.

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

@@ -0,0 +1,55 @@
+export interface AimOptions {
+    /**
+     * How far the primary movement goes past the target, as a share of the
+     * distance (negative: it falls short); the correction comes back.
+     */
+    overshoot?: number;
+    /** When the primary movement's speed peaks, as a share of its time: under a half is a quick start and a longer settle. */
+    peak?: number;
+    /** The share of the whole time the primary movement takes; the correction overlaps its end and takes the rest. */
+    primary?: number;
+    /**
+     * How much a seed changes each of these from move to move, as a share
+     * of its value (the overshoot's from none to twice it at 1, the peak's
+     * and the primary share's a tenth of that).
+     */
+    vary?: number;
+    /** Another seed or index is another move. */
+    seed?: number;
+    index?: number;
+}
+export declare const AIM_DEFAULTS: {
+    overshoot: number;
+    peak: number;
+    primary: number;
+    vary: number;
+    seed: number;
+    index: number;
+};
+/** Why aim options cannot be used, or undefined. */
+export declare function aimProblem(o: AimOptions, what?: string): string | undefined;
+/**
+ * The share of the way a movement has come, from 0 at its start to 1 at
+ * its end, over `s` from 0 to 1: a beta(3, b) distribution's cumulative,
+ * its speed peaking at `peak` (b = 2 / peak − 1), still at both ends.
+ */
+export declare function rise(s: number, peak: number): number;
+/** What a move is, drawn from its options: its overshoot, its primary movement's peak and share. */
+export interface AimShape {
+    overshoot: number;
+    peak: number;
+    primary: number;
+}
+/** A move's own shape: the options, each moved by its seed and index. */
+export declare function aimShape(opts?: AimOptions): AimShape;
+/**
+ * An aimed movement's progress over `x` from 0 to 1 (its share of the
+ * move's time): 0 at the start and 1 at the end, past 1 (or short of it)
+ * where the primary movement lands, still at both ends. Usable as an ease
+ * (blend's, keys'), and what handheld()'s reframes and the SDK's pointer
+ * moves are drawn with.
+ */
+export declare function aimed(opts?: AimOptions): (x: number) => number;
+/** aimed()'s progress for a shape already drawn. */
+export declare function aimAt(shape: AimShape, x: number): number;
+//# sourceMappingURL=aim.d.ts.map

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

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{unit3 as u}from"./noise.js";export const AIM_DEFAULTS={overshoot:.08,peak:.38,primary:.72,vary:.5,seed:1,index:0};export function aimProblem(e,r="aim"){const t=(n,o,i,s)=>n!==void 0&&!(Number.isFinite(n)&&n>=i&&n<=s)?`${r}'s ${o} is from ${String(i)} to ${String(s)}, not ${String(n)}`:void 0;return t(e.overshoot,"overshoot",-.5,1)??t(e.peak,"peak",.15,.6)??t(e.primary,"primary",.3,1)??t(e.vary,"vary",0,1)??(e.seed!==void 0&&!Number.isInteger(e.seed)?`${r}'s seed is a whole number, not ${String(e.seed)}`:void 0)}export function rise(e,r){if(e<=0)return 0;if(e>=1)return 1;const t=2/r-1,n=1-e,o=n**t;return 1-t*(t+1)*(t+2)/2*(o/t-2*o*n/(t+1)+o*n*n/(t+2))}const a=(e,r,t)=>2*u(e,r,t)-1;export function aimShape(e={}){const r={...AIM_DEFAULTS,...e},t=r.vary;return{overshoot:r.overshoot*(1+2*t*a(r.seed,r.index,1)),peak:Math.min(.6,Math.max(.15,r.peak*(1+.2*t*a(r.seed,r.index,2)))),primary:Math.min(1,Math.max(.3,r.primary*(1+.2*t*a(r.seed,r.index,3))))}}export function aimed(e={}){const r=aimProblem(e);if(r)throw new Error(r);const t=aimShape(e);return n=>aimAt(t,n)}export function aimAt(e,r){if(r<=0)return 0;if(r>=1)return 1;const t=1+e.overshoot,n=e.primary;if(n>=1||Math.abs(e.overshoot)<1e-9)return rise(r,e.peak);const o=n*.8,i=t*rise(r/n,e.peak),s=(1-t)*rise((r-o)/(1-o),.45);return i+s}

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

@@ -0,0 +1,203 @@
+import type { Vec3 } from "./vec.js";
+/** What a bake can be told: every value has a default (BAKE_DEFAULTS). */
+export interface BakeOptions {
+    /**
+     * Texels per metre on a surface of weight 1 (default 40: a texel of
+     * 2.5 cm). The atlas's side follows from the surfaces' area.
+     */
+    density?: number;
+    /** The atlas's largest side, texels (default 2048): a denser bake is made coarser to fit. */
+    maxSize?: number;
+    /**
+     * The fewest texels a mesh gets (default 128): a mesh the density would
+     * give fewer (a key, a foot) gets more weight until it has about this many.
+     */
+    minTexels?: number;
+    /**
+     * The fewest texels a mesh's typical island gets (default 16): a mesh made
+     * of many small separate pieces (a keyboard's keys in one mesh) gets more
+     * weight until the island at the median of its area has about this many,
+     * so each piece takes its own light rather than a texel shared with its
+     * neighbours.
+     */
+    islandTexels?: number;
+    /**
+     * Use a mesh's own texture coordinates (uv) for its lightmap when they
+     * already lay it out without overlaps inside 0..1, as a model's baked
+     * textures need, instead of unwrapping it (default true: unwrapping a dense
+     * mesh takes minutes).
+     */
+    ownUv?: boolean;
+    /** Rays each texel gathers per round (default 16). */
+    samples?: number;
+    /** Light bounced from surface to surface, rounds after the direct light (default 4). */
+    bounces?: number;
+    /**
+     * An object's share of the atlas, by its name or an ancestor's: its
+     * texels per metre are multiplied by it (default 1). What the camera
+     * comes close to is worth more.
+     */
+    weight?: Readonly<Record<string, number>>;
+    /** Meshes, by their name or an ancestor's, left without a lightmap: they still cast shadows and bounce light, and stay lit by the scene's lights. */
+    skip?: readonly string[];
+    /** Meshes, by their name or an ancestor's, the bake does not see at all: no lightmap, no shadow, no bounce. */
+    ignore?: readonly string[];
+    /**
+     * Each round smoothed keeping edges: its radius in texels, and how much
+     * farther than their places in the atlas imply two texels may be, in
+     * metres beyond a texel's width, and still be averaged (defaults 3, 0.02).
+     */
+    denoise?: {
+        radius?: number;
+        distance?: number;
+    };
+    /** The most irradiance one sample may add, so a ray that grazes a light leaves no speck (default 40). */
+    clamp?: number;
+    /** Atlas texels a draw covers each way: smaller draws keep a GPU from timing out (default 256). */
+    tile?: number;
+    /**
+     * The moments, s of scenery time, the scenery is posed at to find what
+     * moves (default 0.5, 1, 2, 4, 8, 16, 32): a mesh that moves gets no
+     * lightmap and is left out of the bake's shadows, and a light that moves
+     * is not baked.
+     */
+    posedAt?: readonly number[];
+    /**
+     * A reflection probe: the baked scene seen all round from a point (some
+     * objects hidden, such as the one it sits in), made each time the bake
+     * is laid on and used as the scene's environment, so metal and glass
+     * reflect the lit room. Default none.
+     */
+    probe?: {
+        at: Vec3;
+        hide?: readonly string[];
+        size?: number;
+    };
+}
+/** A bake's settings with every default filled in. */
+export interface ResolvedBake {
+    density: number;
+    maxSize: number;
+    minTexels: number;
+    islandTexels: number;
+    ownUv: boolean;
+    samples: number;
+    bounces: number;
+    weight: Record<string, number>;
+    skip: string[];
+    ignore: string[];
+    denoise: {
+        radius: number;
+        distance: number;
+    };
+    clamp: number;
+    tile: number;
+    posedAt: number[];
+    probe: {
+        at: Vec3;
+        hide: string[];
+        size: number;
+    } | null;
+}
+export declare const BAKE_DEFAULTS: {
+    readonly density: 40;
+    readonly maxSize: 2048;
+    readonly minTexels: 128;
+    readonly islandTexels: 16;
+    readonly ownUv: true;
+    readonly samples: 16;
+    readonly bounces: 4;
+    readonly denoise: {
+        readonly radius: 3;
+        readonly distance: 0.02;
+    };
+    readonly clamp: 40;
+    readonly tile: 256;
+    readonly posedAt: readonly [0.5, 1, 2, 4, 8, 16, 32];
+    readonly probeSize: 256;
+};
+/** The smallest atlas side a bake makes, texels. */
+export declare const BAKE_MIN_SIZE = 64;
+/** What is wrong with a bake's settings, a line each. */
+export declare function bakeProblems(o: BakeOptions): string[];
+/** A bake's settings as the bake uses them: the defaults filled in, names sorted (so they digest the same). */
+export declare function resolveBake(o?: BakeOptions): ResolvedBake;
+/**
+ * The renderer a bake is made on and laid by, as a name for its file: a
+ * bake gathers the same texels each time on one renderer (its rays, their
+ * random numbers and the order they add up in are fixed), but another
+ * GPU's arithmetic (its sines, its rounding) sends the rays a little
+ * differently: most texels differ, by 0.3% at the median between a Mac's
+ * GPU and the CPU, one in a hundred by more than 10%, and the bounces
+ * carry it on. "cpu" for SwiftShader, which draws the same on every computer;
+ * else "gpu-" and a hash of the renderer WebGL names (the GPU and how
+ * Chrome drives it, such as "ANGLE Metal Renderer: Apple M2").
+ */
+export declare function bakeRenderer(gl: string): string;
+/** The renderer name of a bake made on the CPU (SwiftShader): laid by any renderer that has none of its own. */
+export declare const BAKE_CPU = "cpu";
+/** What `allyhub scenery bake` reports: the summary it prints is made from it, the whole of it is the report file. */
+export interface BakeReport {
+    /** The scene's digest: the bake is laid on a scene that digests the same. */
+    digest: string;
+    /** The renderer it was made on (bakeRenderer): a page lays the bake its own renderer made, else the CPU's. */
+    renderer: string;
+    /** The atlas's side, texels. */
+    size: number;
+    /** Texels per metre on a surface of weight 1, after fitting maxSize. */
+    density: number;
+    settings: ResolvedBake;
+    /** Meshes with a lightmap: name, texels per metre, the atlas's share. */
+    baked: {
+        name: string;
+        density: number;
+        share: number;
+        raised?: boolean;
+        triangles: number;
+        seconds: number;
+    }[];
+    /** Meshes left without one, and why. */
+    left: {
+        name: string;
+        why: string;
+    }[];
+    /** The lights baked, and the ones not, with why. */
+    lights: {
+        kind: string;
+        name: string;
+        baked: boolean;
+        why?: string;
+        /**
+         * A point or spot light: what its rays meet first within half a metre,
+         * each mesh with the share of 64 rays it stops (a bulb around the light
+         * stops nearly all: bake.ignore it, or move the light out of it).
+         */
+        around?: {
+            name: string;
+            share: number;
+        }[];
+    }[];
+    /** How the sky is baked: the environment, a hemisphere light, an ambient light, or why not. */
+    sky: string[];
+    /** Irradiance over the baked texels: the darkest tenth, the median, the brightest tenth, the largest. */
+    irradiance: {
+        p10: number;
+        median: number;
+        p90: number;
+        max: number;
+    };
+    /** The share of atlas texels a surface covers. */
+    covered: number;
+    /** Seconds each stage took. */
+    seconds: {
+        unwrap: number;
+        gather: number;
+        read: number;
+        total: number;
+    };
+    /** The bake file's bytes. */
+    bytes: number;
+    /** The GPU it drew on. */
+    gl: string;
+}
+//# sourceMappingURL=bake.d.ts.map

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

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export const BAKE_DEFAULTS={density:40,maxSize:2048,minTexels:128,islandTexels:16,ownUv:!0,samples:16,bounces:4,denoise:{radius:3,distance:.02},clamp:40,tile:256,posedAt:[.5,1,2,4,8,16,32],probeSize:256},BAKE_MIN_SIZE=64;export function bakeProblems(e){const t=[],n=(s,i,a)=>{i!==void 0&&(Number.isFinite(i)&&i>0&&(a===void 0||i<=a)||t.push(`bake.${s} is a number above 0${a===void 0?"":` and at most ${String(a)}`}, not ${String(i)}`))},r=(s,i,a,o)=>{i!==void 0&&(Number.isInteger(i)&&i>=a&&i<=o||t.push(`bake.${s} is a whole number from ${String(a)} to ${String(o)}, not ${String(i)}`))};n("density",e.density,4096),r("maxSize",e.maxSize,BAKE_MIN_SIZE,8192),r("minTexels",e.minTexels,0,1048576),r("islandTexels",e.islandTexels,0,65536),r("samples",e.samples,1,4096),r("bounces",e.bounces,0,16),r("tile",e.tile,16,8192),n("clamp",e.clamp),r("denoise.radius",e.denoise?.radius,0,16),n("denoise.distance",e.denoise?.distance);for(const[s,i]of Object.entries(e.weight??{}))n(`weight["${s}"]`,i,100);for(const s of e.posedAt??[])Number.isFinite(s)&&s>=0||t.push(`bake.posedAt holds moments of scenery time, 0 or later, not ${String(s)}`);if(e.probe){const s=e.probe.at;(!Array.isArray(s)||s.length!==3||!s.every(Number.isFinite))&&t.push("bake.probe.at is a point [x, y, z] in metres"),r("probe.size",e.probe.size,16,2048)}return t}export function resolveBake(e={}){const t={};for(const n of Object.keys(e.weight??{}).sort())t[n]=e.weight?.[n]??1;return{density:e.density??BAKE_DEFAULTS.density,maxSize:e.maxSize??BAKE_DEFAULTS.maxSize,minTexels:e.minTexels??BAKE_DEFAULTS.minTexels,islandTexels:e.islandTexels??BAKE_DEFAULTS.islandTexels,ownUv:e.ownUv??BAKE_DEFAULTS.ownUv,samples:e.samples??BAKE_DEFAULTS.samples,bounces:e.bounces??BAKE_DEFAULTS.bounces,weight:t,skip:[...e.skip??[]].sort(),ignore:[...e.ignore??[]].sort(),denoise:{radius:e.denoise?.radius??BAKE_DEFAULTS.denoise.radius,distance:e.denoise?.distance??BAKE_DEFAULTS.denoise.distance},clamp:e.clamp??BAKE_DEFAULTS.clamp,tile:e.tile??BAKE_DEFAULTS.tile,posedAt:[...e.posedAt??BAKE_DEFAULTS.posedAt],probe:e.probe?{at:[e.probe.at[0],e.probe.at[1],e.probe.at[2]],hide:[...e.probe.hide??[]].sort(),size:e.probe.size??BAKE_DEFAULTS.probeSize}:null}}export function bakeRenderer(e){if(/swiftshader/i.test(e))return BAKE_CPU;let t=2166136261;for(let n=0;n<e.length;n++)t=Math.imul(t^e.charCodeAt(n),16777619);return`gpu-${(t>>>0).toString(16).padStart(8,"0")}`}export const BAKE_CPU="cpu";