allyhub 0.2.0-next.0 → 0.2.0-next.2

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

@@ -0,0 +1,55 @@
+import type { Plan } from "./evaluation-plan.js";
+import type { Primitive } from "./evaluate.js";
+/** What one evaluation did with the cache. */
+export interface EvaluationCacheStats {
+    /** Objects whose rendering was reused from an earlier evaluation. */
+    reused: number;
+    /** Objects whose modifiers and rendering ran in this evaluation. */
+    evaluated: number;
+}
+/**
+ * Results kept between evaluations of a model that is edited and evaluated
+ * again (`evaluate(bpy, { cache })`). An object's plan is an immutable
+ * snapshot of everything its evaluation reads: its source data, its
+ * modifiers' settings, their operands' plans, its materials and images. A
+ * result is reused only when the new plan is structurally equal to the one it
+ * was made from, under the same budgets; anything else is evaluated again. So
+ * no dependency is listed by hand, and none can be left out.
+ *
+ * Entries are kept by the object's evaluated name (an instance's path), and
+ * entries no successful evaluation used are dropped after it. A failed
+ * evaluation stores nothing and leaves the cache as it was.
+ */
+export declare class EvaluationCache {
+    #private;
+    /** What the last evaluation that used this cache did. */
+    get stats(): EvaluationCacheStats;
+    /** Objects with a kept result. */
+    get size(): number;
+    /** Drops every kept result. */
+    clear(): void;
+    /** @internal One evaluation's view of the cache, committed only on success. */
+    begin(options: string): EvaluationCacheRun;
+}
+/** @internal */
+export interface EvaluationCacheRun {
+    get(name: string, plan: Plan): Primitive[] | undefined;
+    set(name: string, plan: Plan, primitives: Primitive[]): void;
+    commit(): void;
+}
+/** A new, empty cache for repeated evaluations of one model. */
+export declare function createEvaluationCache(): EvaluationCache;
+/**
+ * Structural equality of plan data: plain objects by their own enumerable
+ * fields (classes and their structured clones alike), arrays and typed arrays
+ * element by element, numbers with `Object.is` (so -0 and NaN count as
+ * changes or not exactly as they are). Anything else that is not data fails.
+ */
+export declare function samePlanData(a: unknown, b: unknown): boolean;
+/** @internal The evaluation options that bound modifier work, as one key. */
+export declare function cacheOptions(options: {
+    mode?: string | undefined;
+    maxPatternVertices?: number | undefined;
+    maxSurfaceVertices?: number | undefined;
+}): string;
+//# sourceMappingURL=evaluation-cache.d.ts.map

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

@@ -0,0 +1,11 @@
+import { type Bpy, type ModelObject, type ModelMesh, type ModelMaterial } from "./data.js";
+/** Optimistic transaction guard; direct TypeScript array edits need no proxy/version API. */
+export declare function evaluationGuard(bpy: Bpy, enabled: boolean): {
+    transform(object: ModelObject): void;
+    object(object: ModelObject): void;
+    mesh(mesh: ModelMesh): void;
+    material(material: ModelMaterial): void;
+    users(mesh: ModelMesh): void;
+    assertUnchanged: (label: string) => void;
+};
+//# sourceMappingURL=evaluation-guard.d.ts.map

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

@@ -0,0 +1,38 @@
+import { type BevelStep } from "./bevel.js";
+import { type SubdivisionStep } from "./subdivision.js";
+import { type WeightedNormalStep } from "./weighted-normal.js";
+import { type SolidifyStep } from "./solidify.js";
+import { Matrix4 } from "three";
+import { type ArrayStep, type MirrorStep } from "./patterns.js";
+import { type Geometry } from "./geometry.js";
+import { type EvaluatedCurve } from "./curve-eval.js";
+import { type ScrewStep, type Wire } from "./screw.js";
+import { Bpy, ModelMaterial, ModelObject, type BooleanModifier, type ModelModifier } from "./data.js";
+import type { Surface, EvaluationOptions } from "./evaluate.js";
+export interface Plan {
+    source: Geometry;
+    /** A curve object's splines as evaluated (curve-local coordinates). */
+    curve?: EvaluatedCurve;
+    /** A wire profile waiting for a Screw modifier (loose edges, or a curve without a surface). */
+    wire?: Wire;
+    steps: (MirrorStep | ArrayStep | SolidifyStep | SubdivisionStep | BevelStep | ScrewStep | WeightedNormalStep | {
+        type: "BOOLEAN";
+        operand: Plan;
+        relative: Matrix4;
+        settings: Pick<BooleanModifier, "operation" | "material_mode">;
+        label: string;
+    })[];
+}
+/** Shared immutable planner for scene evaluation and single-modifier application. */
+export declare function createEvaluationPlan(bpy: Bpy, options?: EvaluationOptions, selection?: {
+    object: ModelObject;
+    modifier: ModelModifier;
+}): {
+    prepare: (object: ModelObject) => Plan;
+    evaluatePlan: (plan: Plan) => Promise<Geometry>;
+    worldMatrix: (object: ModelObject) => Matrix4;
+    matrices: Map<ModelObject, Matrix4>;
+    materials: Map<ModelMaterial, Surface>;
+    assertUnchanged: (label: string) => void;
+};
+//# sourceMappingURL=evaluation-plan.d.ts.map

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

@@ -0,0 +1,12 @@
+import { type EvaluatedModel } from "./evaluate.js";
+export interface ExportOptions {
+    /** The folder image file paths are relative to: the project's root. Defaults to the current folder. */
+    root?: string;
+    /** The folder a path that starts with ./ or ../ is from: the model's module's. Defaults to the root. */
+    base?: string;
+}
+/** A single proper rotation converts Blender Z-up to glTF Y-up. */
+export declare function glbBytes(model: EvaluatedModel, options?: ExportOptions): Promise<Uint8Array>;
+/** Write a completed file atomically; failed generation does not replace a previous artifact. */
+export declare function exportGLB(model: EvaluatedModel, path: string, options?: ExportOptions): Promise<void>;
+//# sourceMappingURL=export.d.ts.map

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

@@ -0,0 +1,59 @@
+import { type Vec3 } from "./data.js";
+/** A signed distance: negative inside, positive outside. */
+export type Field = (p: Vec3) => number;
+export interface FieldMeshOptions {
+    /** The box sampled: its least and greatest corner, in the field's units. */
+    min: Vec3;
+    max: Vec3;
+    /** The grid's step: the surface's detail is about this fine. */
+    cell: number;
+    /** Newton steps that move each vertex onto the surface; default 3, 0 leaves it where the cell's crossings average. */
+    project?: number;
+    /** The most grid samples it takes before refusing; default FIELD_DEFAULTS.maxSamples. */
+    maxSamples?: number;
+}
+export declare const FIELD_DEFAULTS: {
+    project: number;
+    /** 40 million samples: a 340-cell cube, some seconds of a simple field. */
+    maxSamples: number;
+};
+export interface FieldMesh {
+    vertices: Vec3[];
+    /** Triangles, wound counterclockwise seen from outside (the field's positive side). */
+    faces: [number, number, number][];
+    /**
+     * Whether the field is outside the shape (positive) everywhere on the
+     * box's faces: the surface is then closed. A shape the box cuts is open
+     * where it is cut.
+     */
+    closed: boolean;
+    /** The grid's samples each way. */
+    samples: [number, number, number];
+}
+/** The surface where `field` is 0 inside the box, as vertices and triangles. */
+export declare function meshField(field: Field, o: FieldMeshOptions): FieldMesh;
+/** A sphere. */
+export declare function sphere(p: Vec3, center: Vec3, radius: number): number;
+/** A box of half-sizes `half` about `center`, its edges rounded by `round` (inside the box). */
+export declare function box(p: Vec3, center: Vec3, half: Vec3, round?: number): number;
+/** A capsule from a to b whose radius runs from ra at a to rb at b (exact for equal radii). */
+export declare function capsule(p: Vec3, a: Vec3, b: Vec3, ra: number, rb?: number): number;
+/** An ellipsoid of radii `radii` along the axes about `center` (a bound that is exact on its surface). */
+export declare function ellipsoid(p: Vec3, center: Vec3, radii: Vec3): number;
+declare const AXES: {
+    readonly x: 0;
+    readonly y: 1;
+    readonly z: 2;
+};
+/** A torus about `center` round an axis: `major` from the axis to the tube's middle, `minor` the tube's radius. */
+export declare function torus(p: Vec3, center: Vec3, axis: keyof typeof AXES, major: number, minor: number): number;
+/** A cylinder from a to b of `radius`, its rims rounded by `round`. */
+export declare function cylinder(p: Vec3, a: Vec3, b: Vec3, radius: number, round?: number): number;
+/** Both shapes, joined by a fillet `k` wide (0: a hard join). */
+export declare function smoothUnion(a: number, b: number, k: number): number;
+/** Where both shapes are, the edge rounded `k` wide. */
+export declare function smoothIntersect(a: number, b: number, k: number): number;
+/** The first shape with the second cut out of it, the cut's edge rounded `k` wide. */
+export declare function smoothSubtract(a: number, b: number, k: number): number;
+export {};
+//# sourceMappingURL=field.d.ts.map

package/node_modules/@allyhub-next/model/dist/generated/opensubdiv.d.mts

@@ -0,0 +1,25 @@
+export interface KernelInput {
+  positions: Float32Array;
+  faceSizes: Int32Array;
+  faceIndices: Int32Array;
+  uvCounts: Int32Array;
+  uvIndices: Int32Array;
+  uvValues: Float32Array;
+  /** Vertex pairs of creased edges, and each edge's OpenSubdiv sharpness in [0, 10]. */
+  creaseEdges: Int32Array;
+  creaseSharpness: Float32Array;
+  /** Creased vertices, and each one's sharpness in [0, 10]. */
+  cornerVertices: Int32Array;
+  cornerSharpness: Float32Array;
+}
+export interface SurfaceEvaluator {
+  init(data: KernelInput, level: number, adaptive: boolean, simple: boolean, boundary: number, uvMode: number): string;
+  sample(coordinates: Float32Array): Float32Array | string;
+  delete(): void;
+}
+export interface SubdivisionKernel {
+  SurfaceEvaluator: new () => SurfaceEvaluator;
+  liveEvaluators(): number;
+  allocatedBytes(): number;
+}
+export default function createKernel(options?: { printErr?: (message: string) => void }): Promise<SubdivisionKernel>;

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

@@ -0,0 +1,75 @@
+import { Matrix4, Vector3 } from "three";
+import { Bpy, ModelMesh, type Vec2, type Vec3 } from "./data.js";
+import type { Surface, Primitive } from "./evaluate.js";
+/** Polygon topology and face-corner attributes remain authoritative until tessellation. */
+export interface GeometryFace {
+    vertices: number[];
+    materialIndex: number;
+    smooth: boolean;
+    /** UV layer order matches Geometry.uvLayers; each entry has one value per corner. */
+    uvs: Vec2[][];
+}
+export interface GeometryEdge {
+    vertices: [number, number];
+    sharp: boolean;
+    seam: boolean;
+}
+export interface Geometry {
+    vertices: Vec3[];
+    faces: GeometryFace[];
+    edges: GeometryEdge[];
+    uvLayers: string[];
+    activeUV: number;
+    materials: (Surface | null)[];
+    /** FLOAT/EDGE attributes in Geometry.edges order; omitted for unweighted meshes. */
+    edgeAttributes?: Record<string, number[]>;
+    /** Mesh deform weights; group definitions and names belong to the object. */
+    vertexGroups?: {
+        group: number;
+        weight: number;
+    }[][];
+    /**
+     * The object's group names by index, with any a Boolean operand adds after
+     * them; present with vertexGroups once evaluation planning has set it.
+     */
+    vertexGroupNames?: string[];
+    /**
+     * Corner normals a Weighted Normal modifier wrote, one per face corner;
+     * they replace the automatic ones. No modifier runs after them.
+     */
+    customNormals?: Vec3[][];
+}
+export interface GeometryTriangle {
+    face: number;
+    vertices: [number, number, number];
+    corners: [number, number, number];
+}
+export declare const emptyGeometry: () => Geometry;
+export declare const edgeKey: (a: number, b: number) => string;
+/** A polygon's corners for an error: where it is, so it can be found. */
+/** A point as an error names it, to the micrometre. */
+export declare function pointText(p: readonly number[]): string;
+/** Triangulate a simple polygon in its Newell-normal projection; planar edits may require coplanarity. */
+export declare function triangulate(points: Vector3[], requirePlanar?: boolean): {
+    triangles: number[][];
+    normal: Vector3;
+};
+/** Tessellation is derived data; no modifier receives a silently triangulated source. */
+export declare function tessellate(geometry: Geometry): GeometryTriangle[];
+export declare function sourceGeometry(mesh: ModelMesh, bpy: Pick<Bpy, "owner">, materials: (Surface | null)[]): Geometry;
+/** Preserve the first corner so reversed quads retain their geometric diagonal. */
+export declare function reverseKeepingFirst<T>(values: readonly T[]): T[];
+/** Inverse-transpose normal behavior follows from recomputing normals on transformed polygons. */
+export declare function transformGeometry(geometry: Geometry, matrix: Matrix4): Geometry;
+/** Angle-weighted split normals: flat faces, sharp and non-manifold edges split vertex fans. */
+export declare function cornerNormals(geometry: Geometry): Vec3[][];
+/** Build complete edge topology for kernel output or generated modifier faces. */
+export declare function faceEdges(faces: readonly GeometryFace[]): GeometryEdge[];
+export declare function renderGeometry(geometry: Geometry, matrix: Matrix4): {
+    primitives: Primitive[];
+    bounds: {
+        min: Vec3;
+        max: Vec3;
+    } | null;
+};
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1,77 @@
+import { DataBlock, type RGBA } from "./data.js";
+/** Blender 4.5 image data subset (bpy.types.Image) for material textures. */
+export type ImageSource = "FILE" | "GENERATED";
+/**
+ * The two colour spaces a glTF texture can mean: sRGB for colour (base colour,
+ * emission) and Non-Color for data (metallic/roughness, normal maps).
+ */
+export type ImageColorSpace = "sRGB" | "Non-Color";
+/** glTF core textures are PNG or JPEG files. */
+export declare const IMAGE_EXTENSIONS: readonly [".png", ".jpg", ".jpeg"];
+/** The largest generated image side; files are measured at export. */
+export declare const IMAGE_SIZE_LIMIT = 16384;
+/** image.colorspace_settings: the colour space the image's values are in. */
+export declare class ImageColorSpaceSettings {
+    #private;
+    constructor(name: ImageColorSpace);
+    get name(): ImageColorSpace;
+    set name(value: string);
+}
+/**
+ * A project path: relative, inside the project, with a glTF image extension.
+ * Blender's `//` (relative to the .blend file) means the project's root here.
+ * A path that starts with ./ or ../ stays one: it is from the module that
+ * draws the model (a scenery's module, or the model's own when it is
+ * exported alone), resolved where the file is read.
+ */
+export declare function imagePath(filepath: string): string;
+/**
+ * An image: a project file (images.load) or pixels the model makes
+ * (images.new, then pixels). Pixels are 8-bit, rows bottom to top, as Blender
+ * stores them.
+ */
+export declare class ModelImage extends DataBlock {
+    #private;
+    readonly source: ImageSource;
+    readonly colorspace_settings: ImageColorSpaceSettings;
+    readonly generated_type = "BLANK";
+    constructor(owner: symbol, name: string, source: ImageSource, filepath: string, width: number, height: number, alpha: boolean, colorSpace: ImageColorSpace);
+    private fill;
+    private generated;
+    get filepath(): string;
+    set filepath(value: string);
+    /** [width, height] of a generated image. */
+    get size(): [number, number];
+    readonly channels = 4;
+    /** 32 with an alpha channel, 24 without, as images.new's alpha chose. */
+    get depth(): number;
+    readonly is_float = false;
+    get alpha_mode(): string;
+    set alpha_mode(value: string);
+    get generated_color(): RGBA;
+    /** Setting it fills the image with the colour again, as Blender does. */
+    set generated_color(value: RGBA);
+    /** RGBA floats in [0, 1], rows from the bottom up; length width * height * 4. */
+    get pixels(): number[];
+    set pixels(values: ArrayLike<number>);
+    /** Images are always embedded in the GLB; pack() keeps nothing else. */
+    pack(): void;
+    /** @internal A snapshot for evaluation: RGBA bytes, rows top to bottom (glTF). */
+    snapshot(): EvaluatedImage;
+    /** @internal */
+    copyFrom(source: ModelImage): void;
+}
+/** An image as evaluation captured it: a project file, or pixels top row first. */
+export interface EvaluatedImage {
+    name: string;
+    colorSpace: ImageColorSpace;
+    /** A project-relative PNG or JPEG path, read at export. */
+    file?: string;
+    pixels?: {
+        width: number;
+        height: number;
+        alpha: boolean;
+        rgba: Uint8Array;
+    };
+}
+//# sourceMappingURL=image.d.ts.map

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

@@ -0,0 +1,19 @@
+export { Bpy, BooleanModifier, MirrorModifier, ArrayModifier, SolidifyModifier, WeightedNormalModifier, SubsurfModifier, BevelModifier, ScrewModifier, type ModelModifier, ObjectModifiers, type BooleanOperation, createBpy, defineModel, ModelError, ModelMesh, ModelObject, ModelMaterial, ModelCollection, type Vec3, type Vec2, MeshUVLayer, MeshUVLayers, type RGBA, type ModelDefinition, type ModelParameters, type ModelingContextOptions, type ObjectData, type InstanceType, MaterialSlot, MaterialSlots, type MaterialLink, ImageBlocks, meshData, type CurveKind, type MeshVertex, type MeshVertexData, type MeshEdge, type MeshLoop, type MeshPolygon, type MeshPolygonData, type MeshNormal, } from "./data.js";
+export { evaluate, buildModel, modelImages, type EvaluatedModel, type EvaluationOptions, type BuildModelOptions, type EvaluatedObject, type EvaluatedCurveSpline, type Primitive, type Surface, type SurfaceTexture, } from "./evaluate.js";
+export { createEvaluationCache, EvaluationCache, type EvaluationCacheStats, } from "./evaluation-cache.js";
+export { ModelImage, ImageColorSpaceSettings, type EvaluatedImage, type ImageColorSpace, type ImageSource, } from "./image.js";
+export { ShaderNodeTree, ShaderNode, ShaderNodeBsdfPrincipled, ShaderNodeOutputMaterial, ShaderNodeTexImage, ShaderNodeUVMap, ShaderNodeTexCoord, ShaderNodeMapping, ShaderNodeSeparateColor, ShaderNodeNormalMap, NodeSocket, NodeLink, TreeNodes, TreeLinks, SHADER_NODE_TYPES, type ShaderNodeType, type NodeOf, type AnyShaderNode, type NodeSockets, type SocketList, type SocketType, type SocketValue, type ImageInterpolation, type ImageExtension, } from "./material-nodes.js";
+export { PRINCIPLED_SUPPORTED } from "./material-eval.js";
+export { capabilities } from "./capabilities.js";
+export { MeshAttributes, MeshFloatAttribute } from "./mesh-attributes.js";
+export { VertexGroup, VertexGroups } from "./vertex-groups.js";
+export { loadManifold } from "./boolean.js";
+export type { BMGeometry, DeleteContext, ExtrudeRegionOptions, TriangulateOptions, } from "./bmesh-edit.js";
+export { bmesh, BMesh, BMVert, BMEdge, BMFace, BMLoop, BMUVLayer, BMLayerItem, BMLayerCollection, BMDeformVert, type MatrixRows, } from "./bmesh.js";
+export { applyModifier, type ApplyModifierOptions } from "./apply.js";
+export { uv, type FrameOptions, type ProjectionOptions, type UnwrapOptions, } from "./uv.js";
+export { makeInstancesReal, type MakeInstancesRealOptions, } from "./instances.js";
+export { ModelCurve, CurveSplines, ModelSpline, SplinePoints, SplinePoint, BezierSplinePoint, type Vec4, type SplineType, type HandleType, type CurveDimensions, type TwistMode, type CurveInterpolation, type FillMode, } from "./curve.js";
+export { evaluateCurve, evaluateSpline, type EvaluatedCurve, type EvaluatedSpline, type CurveEvaluationOptions, } from "./curve-eval.js";
+export { FIELD_DEFAULTS, box, capsule, cylinder, ellipsoid, meshField, smoothIntersect, smoothSubtract, smoothUnion, sphere, torus, type Field, type FieldMesh, type FieldMeshOptions, } from "./field.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,18 @@
+import { Bpy, ModelCollection, ModelObject } from "./data.js";
+export interface MakeInstancesRealOptions {
+    /** Parent each new object to the instancer (Blender's use_base_parent); default false. */
+    use_base_parent?: boolean;
+    /** Keep parents among the instanced objects (Blender's use_hierarchy); default false. */
+    use_hierarchy?: boolean;
+}
+/** A collection's objects and its children's, once each, as instancing shows them. */
+export declare function collectionMembers(collection: ModelCollection): ModelObject[];
+/**
+ * AllyHub extension for Blender's bpy.ops.object.duplicates_make_real on one explicit
+ * object, without selection or context: every object its collection instance shows,
+ * nested levels included, becomes a real object sharing its source's data and
+ * modifiers, at the instance's transform, in the instancer's collections. The
+ * instancer stops instancing. Returns the new objects (measured in Blender 4.5.14).
+ */
+export declare function makeInstancesReal(bpy: Bpy, instancer: ModelObject, options?: MakeInstancesRealOptions): ModelObject[];
+//# sourceMappingURL=instances.d.ts.map

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

@@ -0,0 +1,12 @@
+import { type Bpy, type ModelMaterial } from "./data.js";
+import type { EvaluatedImage, ModelImage } from "./image.js";
+import type { Surface } from "./evaluate.js";
+/**
+ * The supported material subset: what a glTF 2.0 metallic-roughness material
+ * says, written as Blender 4.5 writes it and as its glTF exporter reads it.
+ * Anything else fails here, naming the node and socket, instead of being dropped.
+ */
+export declare const PRINCIPLED_SUPPORTED: readonly ["Base Color", "Metallic", "Roughness", "Alpha", "Normal", "Emission Color", "Emission Strength"];
+/** The material an evaluation and export read: its glTF meaning. */
+export declare function materialSurface(material: ModelMaterial, bpy: Bpy, images: Map<ModelImage, EvaluatedImage>): Surface;
+//# sourceMappingURL=material-eval.d.ts.map