allyhub 0.2.0-next.1 → 0.2.0-next.2

package/node_modules/@allyhub-next/model/dist/material-nodes.d.ts

@@ -0,0 +1,279 @@
+import { type Vec2 } from "./data.js";
+import type { ModelImage } from "./image.js";
+/**
+ * Blender 4.5 shader node subset (bpy.types.ShaderNodeTree, Node, NodeSocket,
+ * NodeLink): the nodes a glTF material can say. Socket names, identifiers and
+ * defaults are Blender 4.5.14's (measured, see blender-materials.py).
+ */
+export type SocketType = "RGBA" | "VALUE" | "VECTOR" | "SHADER";
+export type SocketValue = number | number[];
+export type SocketSpec = readonly [
+    name: string,
+    type: SocketType,
+    value?: number | readonly number[],
+    hideValue?: boolean
+];
+/** The Principled BSDF's inputs: name, type, Blender 4.5.14 default, hidden value. */
+export declare const PRINCIPLED_INPUTS: readonly [readonly ["Base Color", "RGBA", readonly [0.8, 0.8, 0.8, 1]], readonly ["Metallic", "VALUE", 0], readonly ["Roughness", "VALUE", 0.5], readonly ["IOR", "VALUE", 1.5], readonly ["Alpha", "VALUE", 1], readonly ["Normal", "VECTOR", readonly [0, 0, 0], true], readonly ["Weight", "VALUE", 0], readonly ["Diffuse Roughness", "VALUE", 0], readonly ["Subsurface Weight", "VALUE", 0], readonly ["Subsurface Radius", "VECTOR", readonly [1, 0.2, 0.1]], readonly ["Subsurface Scale", "VALUE", 0.05], readonly ["Subsurface IOR", "VALUE", 1.4], readonly ["Subsurface Anisotropy", "VALUE", 0], readonly ["Specular IOR Level", "VALUE", 0.5], readonly ["Specular Tint", "RGBA", readonly [1, 1, 1, 1]], readonly ["Anisotropic", "VALUE", 0], readonly ["Anisotropic Rotation", "VALUE", 0], readonly ["Tangent", "VECTOR", readonly [0, 0, 0], true], readonly ["Transmission Weight", "VALUE", 0], readonly ["Coat Weight", "VALUE", 0], readonly ["Coat Roughness", "VALUE", 0.03], readonly ["Coat IOR", "VALUE", 1.5], readonly ["Coat Tint", "RGBA", readonly [1, 1, 1, 1]], readonly ["Coat Normal", "VECTOR", readonly [0, 0, 0], true], readonly ["Sheen Weight", "VALUE", 0], readonly ["Sheen Roughness", "VALUE", 0.5], readonly ["Sheen Tint", "RGBA", readonly [1, 1, 1, 1]], readonly ["Emission Color", "RGBA", readonly [1, 1, 1, 1]], readonly ["Emission Strength", "VALUE", 0], readonly ["Thin Film Thickness", "VALUE", 0], readonly ["Thin Film IOR", "VALUE", 1.33]];
+/** Each supported node type: its Blender type, default name, sockets and enum properties. */
+declare const NODE_TYPES: {
+    readonly ShaderNodeBsdfPrincipled: {
+        readonly type: "BSDF_PRINCIPLED";
+        readonly name: "Principled BSDF";
+        readonly inputs: readonly [readonly ["Base Color", "RGBA", readonly [0.8, 0.8, 0.8, 1]], readonly ["Metallic", "VALUE", 0], readonly ["Roughness", "VALUE", 0.5], readonly ["IOR", "VALUE", 1.5], readonly ["Alpha", "VALUE", 1], readonly ["Normal", "VECTOR", readonly [0, 0, 0], true], readonly ["Weight", "VALUE", 0], readonly ["Diffuse Roughness", "VALUE", 0], readonly ["Subsurface Weight", "VALUE", 0], readonly ["Subsurface Radius", "VECTOR", readonly [1, 0.2, 0.1]], readonly ["Subsurface Scale", "VALUE", 0.05], readonly ["Subsurface IOR", "VALUE", 1.4], readonly ["Subsurface Anisotropy", "VALUE", 0], readonly ["Specular IOR Level", "VALUE", 0.5], readonly ["Specular Tint", "RGBA", readonly [1, 1, 1, 1]], readonly ["Anisotropic", "VALUE", 0], readonly ["Anisotropic Rotation", "VALUE", 0], readonly ["Tangent", "VECTOR", readonly [0, 0, 0], true], readonly ["Transmission Weight", "VALUE", 0], readonly ["Coat Weight", "VALUE", 0], readonly ["Coat Roughness", "VALUE", 0.03], readonly ["Coat IOR", "VALUE", 1.5], readonly ["Coat Tint", "RGBA", readonly [1, 1, 1, 1]], readonly ["Coat Normal", "VECTOR", readonly [0, 0, 0], true], readonly ["Sheen Weight", "VALUE", 0], readonly ["Sheen Roughness", "VALUE", 0.5], readonly ["Sheen Tint", "RGBA", readonly [1, 1, 1, 1]], readonly ["Emission Color", "RGBA", readonly [1, 1, 1, 1]], readonly ["Emission Strength", "VALUE", 0], readonly ["Thin Film Thickness", "VALUE", 0], readonly ["Thin Film IOR", "VALUE", 1.33]];
+        readonly outputs: readonly [readonly ["BSDF", "SHADER"]];
+    };
+    readonly ShaderNodeOutputMaterial: {
+        readonly type: "OUTPUT_MATERIAL";
+        readonly name: "Material Output";
+        readonly inputs: readonly [readonly ["Surface", "SHADER"], readonly ["Volume", "SHADER"], readonly ["Displacement", "VECTOR", readonly [0, 0, 0], true], readonly ["Thickness", "VALUE", 0]];
+        readonly outputs: readonly [];
+    };
+    readonly ShaderNodeTexImage: {
+        readonly type: "TEX_IMAGE";
+        readonly name: "Image Texture";
+        readonly inputs: readonly [readonly ["Vector", "VECTOR", readonly [0, 0, 0], true]];
+        readonly outputs: readonly [readonly ["Color", "RGBA", readonly [0, 0, 0, 0]], readonly ["Alpha", "VALUE", 0]];
+    };
+    readonly ShaderNodeUVMap: {
+        readonly type: "UVMAP";
+        readonly name: "UV Map";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [readonly ["UV", "VECTOR", readonly [0, 0, 0]]];
+    };
+    readonly ShaderNodeTexCoord: {
+        readonly type: "TEX_COORD";
+        readonly name: "Texture Coordinate";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [readonly ["Generated", "VECTOR", readonly [0, 0, 0]], readonly ["Normal", "VECTOR", readonly [0, 0, 0]], readonly ["UV", "VECTOR", readonly [0, 0, 0]], readonly ["Object", "VECTOR", readonly [0, 0, 0]], readonly ["Camera", "VECTOR", readonly [0, 0, 0]], readonly ["Window", "VECTOR", readonly [0, 0, 0]], readonly ["Reflection", "VECTOR", readonly [0, 0, 0]]];
+    };
+    readonly ShaderNodeMapping: {
+        readonly type: "MAPPING";
+        readonly name: "Mapping";
+        readonly inputs: readonly [readonly ["Vector", "VECTOR", readonly [0, 0, 0]], readonly ["Location", "VECTOR", readonly [0, 0, 0]], readonly ["Rotation", "VECTOR", readonly [0, 0, 0]], readonly ["Scale", "VECTOR", readonly [1, 1, 1]]];
+        readonly outputs: readonly [readonly ["Vector", "VECTOR", readonly [0, 0, 0]]];
+    };
+    readonly ShaderNodeSeparateColor: {
+        readonly type: "SEPARATE_COLOR";
+        readonly name: "Separate Color";
+        readonly inputs: readonly [readonly ["Color", "RGBA", readonly [0.8, 0.8, 0.8, 1]]];
+        readonly outputs: readonly [readonly ["Red", "VALUE", 0], readonly ["Green", "VALUE", 0], readonly ["Blue", "VALUE", 0]];
+    };
+    readonly ShaderNodeNormalMap: {
+        readonly type: "NORMAL_MAP";
+        readonly name: "Normal Map";
+        readonly inputs: readonly [readonly ["Strength", "VALUE", 1], readonly ["Color", "RGBA", readonly [0.5, 0.5, 1, 1]]];
+        readonly outputs: readonly [readonly ["Normal", "VECTOR", readonly [0, 0, 0]]];
+    };
+};
+export type ShaderNodeType = keyof typeof NODE_TYPES;
+export declare const SHADER_NODE_TYPES: ShaderNodeType[];
+/** A node's input or output. default_value is live: edit it in place or assign it. */
+export declare class NodeSocket {
+    #private;
+    readonly node: ShaderNode;
+    readonly name: string;
+    readonly identifier: string;
+    readonly type: SocketType;
+    readonly is_output: boolean;
+    readonly hide_value: boolean;
+    enabled: boolean;
+    constructor(node: ShaderNode, [name, type, value, hideValue]: SocketSpec, isOutput: boolean);
+    get default_value(): SocketValue;
+    set default_value(value: SocketValue);
+    /** The links into (an input) or out of (an output) this socket. */
+    get links(): NodeLink[];
+    get is_linked(): boolean;
+}
+/** A node's sockets, by index (at), by name (get) or iterated. */
+export interface SocketList extends Iterable<NodeSocket> {
+    readonly length: number;
+    at(index: number): NodeSocket | undefined;
+    /** By name or identifier; null when the node has none. */
+    get(name: string): NodeSocket | null;
+}
+/** A node type's sockets, also by name: inputs["Base Color"]. */
+export type NodeSockets<K extends string> = Readonly<Record<K, NodeSocket>> & SocketList;
+type InputNames<T extends ShaderNodeType> = (typeof NODE_TYPES)[T]["inputs"][number][0];
+type OutputNames<T extends ShaderNodeType> = (typeof NODE_TYPES)[T]["outputs"][number][0];
+/** A shader node. Its type-specific sockets and settings are on the subclasses. */
+export declare class ShaderNode {
+    #private;
+    readonly bl_idname: ShaderNodeType;
+    readonly type: string;
+    readonly id_data: ShaderNodeTree;
+    readonly inputs: SocketList;
+    readonly outputs: SocketList;
+    label: string;
+    location: Vec2;
+    width: number;
+    select: boolean;
+    hide: boolean;
+    constructor(tree: ShaderNodeTree, idname: ShaderNodeType, name: string);
+    get name(): string;
+    /** Node names are unique in their tree; a taken name gets Blender's .001 suffix. */
+    set name(value: string);
+    get mute(): boolean;
+    set mute(value: boolean);
+    /** @internal Settings that copy with the node. */
+    settings(): Record<string, unknown>;
+    /** @internal */
+    restore(settings: Record<string, unknown>): void;
+}
+export declare class ShaderNodeBsdfPrincipled extends ShaderNode {
+    #private;
+    readonly bl_idname: "ShaderNodeBsdfPrincipled";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeBsdfPrincipled">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeBsdfPrincipled">>;
+    get distribution(): string;
+    set distribution(value: string);
+    get subsurface_method(): string;
+    set subsurface_method(value: string);
+    settings(): Record<string, unknown>;
+}
+export declare class ShaderNodeOutputMaterial extends ShaderNode {
+    #private;
+    readonly bl_idname: "ShaderNodeOutputMaterial";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeOutputMaterial">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeOutputMaterial">>;
+    is_active_output: boolean;
+    get target(): string;
+    set target(value: string);
+    settings(): Record<string, unknown>;
+}
+export type ImageInterpolation = "Linear" | "Closest" | "Cubic" | "Smart";
+export type ImageExtension = "REPEAT" | "EXTEND" | "CLIP" | "MIRROR";
+export declare class ShaderNodeTexImage extends ShaderNode {
+    #private;
+    readonly bl_idname: "ShaderNodeTexImage";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeTexImage">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeTexImage">>;
+    projection_blend: number;
+    get image(): ModelImage | null;
+    set image(value: ModelImage | null);
+    get interpolation(): ImageInterpolation;
+    set interpolation(value: string);
+    get projection(): string;
+    set projection(value: string);
+    get extension(): ImageExtension;
+    set extension(value: string);
+    settings(): Record<string, unknown>;
+}
+export declare class ShaderNodeUVMap extends ShaderNode {
+    readonly bl_idname: "ShaderNodeUVMap";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeUVMap">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeUVMap">>;
+    /** A UV layer's name; empty reads the mesh's active UV layer. */
+    uv_map: string;
+    from_instancer: boolean;
+    settings(): Record<string, unknown>;
+}
+export declare class ShaderNodeTexCoord extends ShaderNode {
+    readonly bl_idname: "ShaderNodeTexCoord";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeTexCoord">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeTexCoord">>;
+    from_instancer: boolean;
+    settings(): Record<string, unknown>;
+}
+export declare class ShaderNodeMapping extends ShaderNode {
+    #private;
+    readonly bl_idname: "ShaderNodeMapping";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeMapping">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeMapping">>;
+    get vector_type(): string;
+    set vector_type(value: string);
+    settings(): Record<string, unknown>;
+}
+export declare class ShaderNodeSeparateColor extends ShaderNode {
+    #private;
+    readonly bl_idname: "ShaderNodeSeparateColor";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeSeparateColor">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeSeparateColor">>;
+    get mode(): string;
+    set mode(value: string);
+    settings(): Record<string, unknown>;
+}
+export declare class ShaderNodeNormalMap extends ShaderNode {
+    #private;
+    readonly bl_idname: "ShaderNodeNormalMap";
+    readonly inputs: NodeSockets<InputNames<"ShaderNodeNormalMap">>;
+    readonly outputs: NodeSockets<OutputNames<"ShaderNodeNormalMap">>;
+    /** The UV layer the tangents come from; empty reads the active UV layer. */
+    uv_map: string;
+    get space(): string;
+    set space(value: string);
+    settings(): Record<string, unknown>;
+}
+declare const NODE_CLASSES: {
+    readonly ShaderNodeBsdfPrincipled: typeof ShaderNodeBsdfPrincipled;
+    readonly ShaderNodeOutputMaterial: typeof ShaderNodeOutputMaterial;
+    readonly ShaderNodeTexImage: typeof ShaderNodeTexImage;
+    readonly ShaderNodeUVMap: typeof ShaderNodeUVMap;
+    readonly ShaderNodeTexCoord: typeof ShaderNodeTexCoord;
+    readonly ShaderNodeMapping: typeof ShaderNodeMapping;
+    readonly ShaderNodeSeparateColor: typeof ShaderNodeSeparateColor;
+    readonly ShaderNodeNormalMap: typeof ShaderNodeNormalMap;
+};
+export type NodeOf<T extends ShaderNodeType> = InstanceType<(typeof NODE_CLASSES)[T]>;
+export type AnyShaderNode = NodeOf<ShaderNodeType>;
+/** node_tree.nodes */
+export declare class TreeNodes implements Iterable<AnyShaderNode> {
+    #private;
+    constructor(tree: ShaderNodeTree);
+    /** A node of a supported type; other Blender node types are refused. */
+    new<T extends ShaderNodeType>(type: T): NodeOf<T>;
+    get(name: string): AnyShaderNode | null;
+    at(index: number): AnyShaderNode | undefined;
+    /** Removes the node and every link to or from it. */
+    remove(node: ShaderNode): void;
+    clear(): void;
+    get length(): number;
+    [Symbol.iterator](): Iterator<AnyShaderNode>;
+}
+export declare class NodeLink {
+    readonly from_socket: NodeSocket;
+    readonly to_socket: NodeSocket;
+    constructor(from: NodeSocket, to: NodeSocket);
+    get from_node(): ShaderNode;
+    get to_node(): ShaderNode;
+    readonly is_valid = true;
+    readonly is_muted = false;
+}
+/** node_tree.links */
+export declare class TreeLinks implements Iterable<NodeLink> {
+    #private;
+    constructor(tree: ShaderNodeTree);
+    /**
+     * A link from an output to an input, given in either order as Blender takes
+     * them. An input holds one link: a new one replaces it. Cycles are refused.
+     */
+    new(a: NodeSocket, b: NodeSocket, verify_limits?: boolean): NodeLink;
+    remove(link: NodeLink): void;
+    clear(): void;
+    get length(): number;
+    at(index: number): NodeLink | undefined;
+    [Symbol.iterator](): Iterator<NodeLink>;
+    /** @internal */
+    of(socket: NodeSocket): NodeLink[];
+    /** @internal */
+    dropNode(node: ShaderNode): void;
+}
+/** A material's node tree (material.node_tree). */
+export declare class ShaderNodeTree {
+    #private;
+    readonly owner: symbol;
+    readonly bl_idname = "ShaderNodeTree";
+    readonly nodes: TreeNodes;
+    readonly links: TreeLinks;
+    constructor(owner: symbol, alive: () => boolean);
+    /** @internal */
+    assertAlive(): void;
+    /** @internal Blender's default tree: a Principled BSDF into a Material Output. */
+    static standard(owner: symbol, alive: () => boolean): ShaderNodeTree;
+    /** @internal A deep copy: nodes, their settings, socket values and links. */
+    copy(owner: symbol, alive: () => boolean): ShaderNodeTree;
+    /** @internal A comparable description, for the evaluation guard. */
+    describe(): unknown;
+}
+export {};
+//# sourceMappingURL=material-nodes.d.ts.map

package/node_modules/@allyhub-next/model/dist/mesh-attributes.d.ts

@@ -0,0 +1,27 @@
+import { type ModelMesh } from "./data.js";
+/** Initial Blender FLOAT/EDGE attribute storage; values are validated at evaluation. */
+export declare class MeshFloatAttribute {
+    readonly domain = "EDGE";
+    readonly data_type = "FLOAT";
+    readonly data: {
+        value: number;
+    }[];
+    name: string;
+    constructor(name: string, size: number);
+}
+export declare class MeshAttributes implements Iterable<MeshFloatAttribute> {
+    private entries;
+    private readonly mesh;
+    constructor(mesh: ModelMesh);
+    new(name: string, type: string, domain: string): MeshFloatAttribute;
+    get(name: string): MeshFloatAttribute | null;
+    get length(): number;
+    remove(attribute: MeshFloatAttribute): void;
+    clear(): void;
+    [Symbol.iterator](): Iterator<MeshFloatAttribute>;
+    /** @internal Adopt fully validated attribute storage during atomic mesh application. */
+    adopt(source: MeshAttributes): void;
+    /** @internal Clone values without retaining mutable element identities. */
+    copyFrom(source: MeshAttributes): void;
+}
+//# sourceMappingURL=mesh-attributes.d.ts.map

package/node_modules/@allyhub-next/model/dist/mesh-queries.d.ts

@@ -0,0 +1,34 @@
+import type { Vec3 } from "./data.js";
+/**
+ * What Blender computes from a mesh's positions on demand: a polygon's normal,
+ * center and area and a vertex's normal (MeshPolygon.normal, .center, .area,
+ * MeshVertex.normal). Measured against Blender 4.5.14
+ * (test/mesh-query-reference.test.ts).
+ */
+interface Positions {
+    readonly vertices: readonly {
+        readonly co: Vec3;
+    }[];
+}
+interface Corners {
+    readonly vertices: readonly number[];
+}
+/** The unit normal; a polygon with no area faces +Z, as in Blender. */
+export declare function polygonNormal(mesh: Positions, polygon: Corners): Vec3;
+/** The mean of the polygon's vertices. */
+export declare function polygonCenter(mesh: Positions, polygon: Corners): Vec3;
+/** The area: of the polygon's projection along its normal, when it is not planar. */
+export declare function polygonArea(mesh: Positions, polygon: Corners): number;
+type Mesh = Positions & {
+    readonly polygons: readonly Corners[];
+};
+/**
+ * Every vertex's normal: the normals of the polygons around it, each weighted
+ * by the polygon's angle at the vertex. A vertex on no polygon points away
+ * from the origin; one whose polygons cancel out has a zero normal.
+ */
+export declare function vertexNormals(mesh: Mesh): Vec3[];
+/** One vertex's normal, as vertexNormals gives it (it reads every polygon). */
+export declare function vertexNormal(mesh: Mesh, index: number): Vec3;
+export {};
+//# sourceMappingURL=mesh-queries.d.ts.map

package/node_modules/@allyhub-next/model/dist/names.d.ts

@@ -0,0 +1,9 @@
+/** Name allocation is separate for global IDs and object/custom-data lists. */
+export type NameDomain = "ID" | "LOCAL" | "UV";
+/**
+ * Independently implement pinned allocation behavior, without Blender code.
+ * ID collisions reuse low suffix holes; local lists increment the requested
+ * suffix. Long IDs shorten and retry; local lists reserve suffix byte space.
+ */
+export declare function allocateName(requested: string, names: Iterable<string>, domain: NameDomain): string;
+//# sourceMappingURL=names.d.ts.map

package/node_modules/@allyhub-next/model/dist/patterns.d.ts

@@ -0,0 +1,21 @@
+import { Matrix4 } from "three";
+import { type ArrayModifier, type MirrorModifier } from "./data.js";
+import { type Geometry } from "./geometry.js";
+export interface MirrorStep {
+    type: "MIRROR";
+    settings: Pick<MirrorModifier, "use_axis" | "use_mirror_merge" | "use_mirror_vertex_groups" | "merge_threshold" | "use_mirror_u" | "use_mirror_v" | "offset_u" | "offset_v" | "mirror_offset_u" | "mirror_offset_v">;
+    /** Mirror object's coordinates to the modified object's local coordinates. */
+    relative: Matrix4;
+    label: string;
+}
+export interface ArrayStep {
+    type: "ARRAY";
+    settings: Pick<ArrayModifier, "fit_type" | "count" | "fit_length" | "use_relative_offset" | "relative_offset_displace" | "use_constant_offset" | "constant_offset_displace" | "use_merge_vertices" | "use_merge_vertices_cap" | "merge_threshold" | "offset_u" | "offset_v">;
+    relative: Matrix4;
+    label: string;
+}
+export declare function snapshotMirror(modifier: MirrorModifier, relative: Matrix4, label: string): MirrorStep;
+export declare function snapshotArray(modifier: ArrayModifier, relative: Matrix4, label: string): ArrayStep;
+export declare function mirrorGeometry(source: Geometry, step: MirrorStep, maxVertices?: number): Geometry;
+export declare function arrayGeometry(source: Geometry, step: ArrayStep, maxVertices?: number): Geometry;
+//# sourceMappingURL=patterns.d.ts.map

package/node_modules/@allyhub-next/model/dist/png.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An 8-bit PNG of RGBA pixels, rows top to bottom: RGBA with alpha, else RGB.
+ * Unfiltered rows and fixed deflate settings make the same bytes every time.
+ */
+export declare function encodePng(width: number, height: number, rgba: Uint8Array, alpha: boolean): Uint8Array;
+/** A PNG's or JPEG's kind and size from its header, or null for anything else. */
+export declare function imageInfo(bytes: Uint8Array): {
+    mimeType: "image/png" | "image/jpeg";
+    width: number;
+    height: number;
+} | null;
+//# sourceMappingURL=png.d.ts.map

package/node_modules/@allyhub-next/model/dist/polygon-triangulation.d.ts

@@ -0,0 +1,4 @@
+import type { Vector2 } from "three";
+/** Ear fallback that retains collinear boundary roles and their corner attributes. */
+export declare function triangulateBoundary(points: readonly Vector2[]): number[][];
+//# sourceMappingURL=polygon-triangulation.d.ts.map

package/node_modules/@allyhub-next/model/dist/program-location.d.ts

@@ -0,0 +1,7 @@
+/** The first place in the program's own files that a stack passes through. */
+export declare function programLocation(stack: string, own: (path: string) => boolean): {
+    path: string;
+    line: number;
+    column: number;
+} | undefined;
+//# sourceMappingURL=program-location.d.ts.map

package/node_modules/@allyhub-next/model/dist/report.d.ts

@@ -0,0 +1,70 @@
+/**
+ * A built model as plain data: what `allyhub model inspect` and `model build`
+ * print. Bounds are world-space surface bounds in Blender Z-up metres; a
+ * transform-only object's are null. Textures name their image and where it
+ * comes from, never its pixels.
+ */
+import type { EvaluatedCurveSpline, EvaluatedModel, Surface, SurfaceTexture } from "./evaluate.js";
+import type { Vec3 } from "./data.js";
+import type { ImageColorSpace } from "./image.js";
+export interface TextureReport {
+    image: string;
+    colorSpace: ImageColorSpace;
+    /** A project path, for an image read from a file. */
+    file?: string;
+    /** Width and height, for an image made of pixels. */
+    size?: [number | undefined, number | undefined];
+    uvMap: string | null;
+    interpolation: SurfaceTexture["interpolation"];
+    extension: SurfaceTexture["extension"];
+    transform?: NonNullable<SurfaceTexture["transform"]>;
+}
+export type MaterialReport = Omit<Surface, "baseColorTexture" | "metallicRoughnessTexture" | "normalTexture" | "emissionTexture"> & {
+    baseColorTexture: TextureReport | undefined;
+    metallicRoughnessTexture: TextureReport | undefined;
+    normalTexture: (TextureReport & {
+        scale: number;
+    }) | undefined;
+    emissionTexture: TextureReport | undefined;
+};
+export interface ObjectReport {
+    name: string;
+    parent: string | null | undefined;
+    matrix: number[];
+    bounds: {
+        min: Vec3;
+        max: Vec3;
+    } | null;
+    triangles: number;
+    /** One per primitive, in order. */
+    materials: (MaterialReport | null)[];
+    uvLayers: string[];
+    data?: string;
+    instance?: {
+        object: string;
+        collection: string;
+        instancer: string;
+    };
+    curve?: {
+        splines: EvaluatedCurveSpline[];
+        bounds: {
+            min: Vec3;
+            max: Vec3;
+        } | null;
+    };
+}
+export interface ModelReport {
+    /** The model's module. */
+    file: string;
+    /** The GLB written, when the build exported one. */
+    glb?: string;
+    schemaVersion: EvaluatedModel["schemaVersion"];
+    seed: number;
+    units: EvaluatedModel["units"];
+    upAxis: EvaluatedModel["upAxis"];
+    triangles: number;
+    objects: ObjectReport[];
+}
+/** A built model's report; `file` names its module, `seed` the seed it was built with. */
+export declare function modelReport(model: EvaluatedModel, file: string, seed: number): ModelReport;
+//# sourceMappingURL=report.d.ts.map

package/node_modules/@allyhub-next/model/dist/screw.d.ts

@@ -0,0 +1,38 @@
+import { Matrix4 } from "three";
+import { type ScrewModifier, type Vec3 } from "./data.js";
+import { type Geometry } from "./geometry.js";
+import type { Surface } from "./evaluate.js";
+/** A wire profile: vertices and loose edges, as a mesh or a curve without a surface gives them. */
+export interface Wire {
+    vertices: Vec3[];
+    edges: [number, number][];
+    /** UV layers the revolved surface gets: a mesh's own layer names, or UVMap for a curve. */
+    uvLayers: string[];
+}
+export interface ScrewStep {
+    type: "SCREW";
+    label: string;
+    wire: Wire;
+    materials: (Surface | null)[];
+    origin: Vec3;
+    axis: Vec3;
+    angle: number;
+    steps: number;
+    iterations: number;
+    offset: number;
+    merge: number | null;
+    calculate: boolean;
+    flip: boolean;
+    smooth: boolean;
+    stretchU: boolean;
+    stretchV: boolean;
+}
+/** Snapshot a Screw modifier with the wire it revolves (relative: the axis object's frame, if any). */
+export declare function snapshotScrew(modifier: ScrewModifier, mode: "RENDER" | "VIEWPORT", relative: Matrix4 | null, wire: Wire, materials: (Surface | null)[], label: string): ScrewStep;
+/**
+ * Revolve a wire profile as Blender's Screw modifier does (measured): copies of the
+ * vertices step by step, a face per edge and step (edge-major), merged on-axis
+ * vertices kept once, UVs from the step and the height along the axis.
+ */
+export declare function screwGeometry(step: ScrewStep, maxSurfaceVertices: number): Geometry;
+//# sourceMappingURL=screw.d.ts.map

package/node_modules/@allyhub-next/model/dist/solidify.d.ts

@@ -0,0 +1,11 @@
+import { type SolidifyModifier } from "./data.js";
+import { type Geometry } from "./geometry.js";
+export interface SolidifyStep {
+    type: "SOLIDIFY";
+    label: string;
+    settings: Pick<SolidifyModifier, "thickness" | "offset" | "use_even_offset" | "use_quality_normals" | "use_rim" | "use_rim_only" | "use_flip_normals" | "material_offset" | "material_offset_rim" | "thickness_clamp">;
+}
+export declare function snapshotSolidify(modifier: SolidifyModifier, label: string): SolidifyStep;
+/** Offset an oriented manifold surface, retaining polygon and face-corner domains. */
+export declare function solidifyGeometry(source: Geometry, step: SolidifyStep, maxVertices?: number): Geometry;
+//# sourceMappingURL=solidify.d.ts.map

package/node_modules/@allyhub-next/model/dist/subdivision.d.ts

@@ -0,0 +1,21 @@
+import { type SubsurfModifier } from "./data.js";
+import { type Geometry } from "./geometry.js";
+import type { SubdivisionKernel } from "./generated/opensubdiv.mjs";
+export interface SubdivisionStep {
+    type: "SUBSURF";
+    label: string;
+    levels: number;
+    quality: number;
+    simple: boolean;
+    limit: boolean;
+    boundary: number;
+    uvMode: number;
+    /** Whether the crease_edge attribute sharpens edges (use_creases). */
+    creases: boolean;
+}
+export declare function snapshotSubdivision(modifier: SubsurfModifier, mode: "RENDER" | "VIEWPORT", label: string): SubdivisionStep;
+export declare function subdivisionKernel(): Promise<SubdivisionKernel>;
+/** OpenSubdiv's sharpness for a Blender crease value in [0, 1] (measured). */
+export declare function creaseSharpness(crease: number): number;
+export declare function subdivideGeometry(source: Geometry, step: SubdivisionStep, maxVertices?: number): Promise<Geometry>;
+//# sourceMappingURL=subdivision.d.ts.map

package/node_modules/@allyhub-next/model/dist/three.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The model as three.js objects: the adapter a scenery uses to place a model
+ * built in its own page. The core of the package has no three.js scene
+ * objects; this entry is the only one that makes them.
+ */
+import type { EvaluationCache } from "./evaluation-cache.js";
+import { Group, type Texture } from "three";
+import { type EvaluatedModel } from "./evaluate.js";
+import { type ModelDefinition, type ModelParameters } from "./data.js";
+import type { EvaluatedImage } from "./image.js";
+/**
+ * Convert the exact evaluated mesh used by GLB export into a preview hierarchy.
+ * File images come loaded in `files` (modelObject loads them); pixels a model
+ * made become textures here. Textures sample, wrap and transform as glTF
+ * viewers read the exported file (three's GLTFLoader).
+ */
+export declare function modelGroup(model: EvaluatedModel, files?: ReadonlyMap<EvaluatedImage, Texture>): Group;
+/** How a model is built for a scenery: `buildModel`'s options. */
+export interface ModelBuildOptions {
+    seed?: number | undefined;
+    maxPatternVertices?: number | undefined;
+    maxSurfaceVertices?: number | undefined;
+    maxInstances?: number | undefined;
+    /** Results kept between rebuilds (`createEvaluationCache()`); see `evaluate`. */
+    cache?: EvaluationCache | undefined;
+}
+/**
+ * Where a model's image files are read: a scenery's host passes itself (its
+ * `texture` reads a picture as it reads any other, and records the read).
+ */
+export interface ModelTextures {
+    texture(file: string, options: {
+        colorSpace: "srgb" | "linear";
+    }): Promise<Texture>;
+}
+/**
+ * A model as a three.js object for a scenery of one's own: built, its image
+ * files read as the scenery reads any picture, drawn as its GLB is. The group
+ * turns Blender's Z up to the world's Y up with its own rotation, so a scenery
+ * places it inside a group of its own. It is not added to the scene.
+ */
+export declare function modelObject(w: ModelTextures, model: ModelDefinition, parameters?: ModelParameters, options?: ModelBuildOptions): Promise<Group>;
+//# sourceMappingURL=three.d.ts.map

package/node_modules/@allyhub-next/model/dist/uv-project.d.ts

@@ -0,0 +1,62 @@
+import { type Vec3 } from "./data.js";
+import type { BMesh, BMFace, BMUVLayer } from "./bmesh-data.js";
+/**
+ * UV projections as Blender 4.5.14's bpy.ops.uv operators make them (measured,
+ * see blender-uv.py), as functions of a BMesh and explicit faces: no edit mode,
+ * no selection and no 3D view. Every value the operator reads from the scene
+ * (the projection's centre and frame, the cube size) is a parameter with
+ * Blender's default.
+ */
+/** What every projection takes. */
+export interface ProjectionOptions {
+    /** The faces to project; all of the BMesh's by default (Blender: the selected faces). */
+    faces?: readonly BMFace[];
+    /** The UV layer to write; the active one by default, made if there is none. */
+    uv_layer?: BMUVLayer;
+    /** Scale the result to fill [0, 1] on each axis (Blender's scale_to_bounds). */
+    scale_to_bounds?: boolean;
+    /** Clamp the result to [0, 1] (Blender's clip_to_bounds; ignored with scale_to_bounds). */
+    clip_to_bounds?: boolean;
+}
+/** The centre and frame a projection is made in: Blender's ALIGN_TO_OBJECT. */
+export interface FrameOptions {
+    /** The projection's centre in mesh coordinates: by default the centre of the faces' bounds. */
+    center?: Vec3;
+    /**
+     * Rows of a 3x3 rotation from mesh coordinates to the projection's frame, whose
+     * Z is the axis (Blender: the object's own axes); identity by default.
+     */
+    orientation?: readonly (readonly number[])[];
+    /** POLAR_ZX (default) or POLAR_ZY: which side the U seam is on. */
+    align?: "POLAR_ZX" | "POLAR_ZY";
+    /** PINCH (default) leaves a corner on the axis as it falls; FAN gives it its face's mean U. */
+    pole?: "PINCH" | "FAN";
+    /** Blender's view-based directions need a 3D view; only ALIGN_TO_OBJECT is offered. */
+    direction?: "ALIGN_TO_OBJECT";
+    /** Blender's seam option: only false (the default) is offered (see capabilities). */
+    seam?: boolean;
+}
+/**
+ * bpy.ops.uv.cube_project: each face projected along its normal's dominant axis
+ * (ties go to Z, then Y), u = (p - center) / cube_size + 0.5 on the other two.
+ * cube_size defaults to the BMesh's largest bounds side (Blender: the object's
+ * largest dimension when the operator's size is not set).
+ */
+export declare function cube_project(bm: BMesh, options?: ProjectionOptions & {
+    cube_size?: number;
+    center?: Vec3;
+}): void;
+/**
+ * bpy.ops.uv.cylinder_project with ALIGN_TO_OBJECT: U from the angle about the
+ * frame's Z axis (POLAR_ZX: U 0 towards -Y; POLAR_ZY a quarter turn on), V = z / 2 + 0.5.
+ * Blender's radius has no effect in this direction, so it is not taken.
+ */
+export declare function cylinder_project(bm: BMesh, options?: ProjectionOptions & FrameOptions): void;
+/** bpy.ops.uv.sphere_project with ALIGN_TO_OBJECT: U as the cylinder's, V from the elevation. */
+export declare function sphere_project(bm: BMesh, options?: ProjectionOptions & FrameOptions): void;
+/**
+ * bpy.ops.uv.reset: each face fills the unit square, a triangle (0,0) (1,0) (1,1),
+ * a polygon of n corners around the unit circle from the top, clockwise.
+ */
+export declare function reset(bm: BMesh, options?: Pick<ProjectionOptions, "faces" | "uv_layer">): void;
+//# sourceMappingURL=uv-project.d.ts.map