material-designer-runtime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vanrez Nez
+
+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.

package/README.md

@@ -0,0 +1,31 @@
+# material-designer-runtime
+
+Lightweight runtime for loading Material Designer node graph documents and applying them to Three.js meshes.
+
+## Install
+
+```sh
+npm install material-designer-runtime three@0.184.0
+```
+
+`three` is a peer dependency — this package uses its WebGPU renderer and TSL, so install the exact
+supported version alongside it.
+
+## Usage
+
+```ts
+import { MaterialGraphRuntime } from "material-designer-runtime";
+
+const runtime = new MaterialGraphRuntime()
+  .setRenderer(renderer)
+  .setBackend("offline")
+  .fromDocument(document);
+
+await runtime.refresh();
+mesh.material = runtime.material;
+
+runtime.setOutputResolution(1024);
+runtime.setNodeParam("noise", "scale", 18);
+```
+
+The editor owns UI state, selection, storage, presets, and undo history. This package owns only graph document loading, compilation, baking, direct parameter updates, and the material surface.

package/dist/document.d.ts

@@ -0,0 +1,32 @@
+import { type NodeRegistry } from "./graph/registry";
+import { type GraphChange, type MaterialGraphDocument, type MaterialGraphSource } from "./graph/types";
+export declare const MATERIAL_DOCUMENT_VERSION = 2;
+export declare function cloneMaterialDocument(doc: MaterialGraphDocument): MaterialGraphDocument;
+export declare function createDefaultMaterialDocument(): MaterialGraphDocument;
+export declare function migrateMaterialDocument(doc: MaterialGraphDocument): MaterialGraphDocument;
+export declare class MaterialGraphSession implements MaterialGraphSource {
+    private readonly registry;
+    private doc;
+    private readonly listeners;
+    private lastError_;
+    private soloNode_;
+    constructor(doc?: MaterialGraphDocument, registry?: NodeRegistry);
+    get document(): MaterialGraphDocument;
+    get lastError(): string | null;
+    get soloNode(): string | null;
+    getRegistry(): NodeRegistry;
+    compileBundle(opts: import("./graph/compiler").CompileOptions): import("./graph/compiler").CompiledSockets;
+    onChange(fn: (change: GraphChange) => void): () => void;
+    setDocument(doc: MaterialGraphDocument): void;
+    getDocument(): MaterialGraphDocument;
+    setSoloNode(nodeId: string | null): void;
+    setOutputResolution(size: number): void;
+    setOutputTargets(targets: {
+        resolution?: number;
+        size?: number;
+    }): void;
+    setNodeParam(nodeId: string, key: string, value: unknown): boolean;
+    updateNodeParams(nodeId: string, patch: Record<string, unknown>): boolean;
+    private validate;
+    private emit;
+}

package/dist/graph/bake-service.d.ts

@@ -0,0 +1,84 @@
+import * as THREE from "three";
+import { RenderTarget, type WebGPURenderer, type MeshBasicNodeMaterial } from "three/webgpu";
+import { type CacheEntry } from "./compiler";
+import type { MaterialGraphSource, MaterialValue, PbrSocket } from "./types";
+export declare const SURFACE_CHANNELS: PbrSocket[];
+export interface BakeOptions {
+    channels?: PbrSocket[];
+    size?: number;
+    soloNodeId?: string;
+    label?: string;
+    source?: string;
+}
+export interface BakeReport {
+    runId: number;
+    source: string | undefined;
+    phase: "nodes" | "shaders" | "render" | "done";
+    nodeCount: number;
+    compileMs: number;
+    texturesTotal: number;
+    totalMs: number;
+}
+export declare class BakedTextureSet {
+    readonly channels: PbrSocket[];
+    private readonly targets;
+    private readonly mats;
+    private readonly cacheTargets;
+    private readonly cacheMats;
+    cachePlan: CacheEntry[];
+    uniforms: Map<string, Record<string, MaterialValue>>;
+    heightTarget: RenderTarget | null;
+    hasHeight: boolean;
+    present: Set<"roughness" | "normal" | "baseColor" | "metallic" | "emission" | "ambientOcclusion">;
+    signature: string;
+    size: number;
+    constructor(size: number, channels: PbrSocket[]);
+    resize(size: number): void;
+    target(ch: PbrSocket): RenderTarget;
+    channelMaterial(ch: PbrSocket | "height"): MeshBasicNodeMaterial;
+    cacheTarget(cacheId: string, size?: number, mips?: boolean): RenderTarget;
+    cacheMaterial(cacheId: string): MeshBasicNodeMaterial;
+    cacheTexture(cacheId: string, size?: number, mips?: boolean): THREE.Texture;
+    firstTarget(): RenderTarget | null;
+    ensureHeightTarget(): RenderTarget;
+    texture(ch: PbrSocket): THREE.Texture | null;
+    flushCaches(): void;
+    dispose(): void;
+}
+export interface BakeProgress {
+    completed: number;
+    total: number;
+    active: string | null;
+}
+export declare class MaterialBakeService {
+    private renderer;
+    private compileGateDepth;
+    get rendererBusy(): boolean;
+    private queue;
+    private completed;
+    private total;
+    private active;
+    private readonly progressListeners;
+    private readonly reportListeners;
+    private bakeRunId;
+    private scratch;
+    private scratchSize;
+    private readonly scratchCaches;
+    private scratchCacheSize;
+    attachRenderer(renderer: WebGPURenderer): void;
+    get hasRenderer(): boolean;
+    onProgress(cb: (p: BakeProgress) => void): () => void;
+    private emitProgress;
+    onBakeReport(cb: (r: BakeReport) => void): () => void;
+    private emitReport;
+    private enqueue;
+    createTextureSet(channels?: PbrSocket[], size?: number): BakedTextureSet;
+    bakeInto(set: BakedTextureSet, graph: MaterialGraphSource, opts?: BakeOptions): Promise<boolean>;
+    private gpuSync;
+    rerenderInto(set: BakedTextureSet, source?: string): Promise<void>;
+    bake(graph: MaterialGraphSource, opts?: BakeOptions): Promise<BakedTextureSet>;
+    readImage(graph: MaterialGraphSource, channel: PbrSocket, size?: number): Promise<ImageData | null>;
+    private scratchTarget;
+    private scratchCache;
+}
+export declare const bakeService: MaterialBakeService;

package/dist/graph/channel-baker.d.ts

@@ -0,0 +1,10 @@
+import { RenderTarget, MeshBasicNodeMaterial, type WebGPURenderer } from "three/webgpu";
+import type { MaterialValue, PbrSocket } from "./types";
+export declare const FIELD_CHANNELS: PbrSocket[];
+export declare const COLOR_CHANNELS: PbrSocket[];
+export declare function encodeChannel(node: MaterialValue, channel: PbrSocket): MaterialValue;
+export declare function makeChannelMaterial(): MeshBasicNodeMaterial;
+export declare function compileMaterialsAsync(renderer: WebGPURenderer, materials: MeshBasicNodeMaterial[]): Promise<void>;
+export declare function renderCacheToTarget(renderer: WebGPURenderer, material: MeshBasicNodeMaterial, rt: RenderTarget): void;
+export declare function renderMaterialToTarget(renderer: WebGPURenderer, material: MeshBasicNodeMaterial, rt: RenderTarget, isNormal?: boolean): void;
+export declare function renderColorNodeToTarget(renderer: WebGPURenderer, colorNode: MaterialValue, rt: RenderTarget, isNormal?: boolean): void;

package/dist/graph/compiler.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from "three";
+import { MeshStandardNodeMaterial, MeshPhysicalNodeMaterial } from "three/webgpu";
+import { type MaterialBackend, type MaterialBundle, type MaterialGraphDocument, type MaterialValue, type PortKind } from "./types";
+import { type NodeRegistry } from "./registry";
+export interface CompiledMaterial {
+    material: MeshStandardNodeMaterial;
+    uniforms: Map<string, Record<string, MaterialValue>>;
+}
+export interface CacheSizing {
+    minSize?: number;
+    size?: number;
+}
+export type CacheAlloc = (cacheId: string, kind: PortKind, sizing?: CacheSizing) => THREE.Texture;
+export interface CacheEntry {
+    cacheId: string;
+    kind: PortKind;
+    colorNode: MaterialValue;
+    sizing?: CacheSizing;
+}
+export interface CompileOptions {
+    backend: MaterialBackend;
+    soloNodeId?: string;
+    allocCache?: CacheAlloc;
+    outputResolution?: number;
+}
+export interface CompiledSockets {
+    bundle: MaterialBundle;
+    uniforms: Map<string, Record<string, MaterialValue>>;
+    cachePlan: CacheEntry[];
+}
+export declare function readOutputResolution(doc: MaterialGraphDocument): number;
+export declare function countGraphNodes(doc: MaterialGraphDocument): number;
+export declare function compileSockets(doc: MaterialGraphDocument, registry: NodeRegistry, optsIn: CompileOptions): CompiledSockets;
+export declare function newSurfaceMaterial(): MeshPhysicalNodeMaterial;
+export declare function applyBundle(material: MeshPhysicalNodeMaterial, bundle: MaterialBundle): void;
+export declare function compileGraph(doc: MaterialGraphDocument, registry: NodeRegistry, opts: CompileOptions): CompiledMaterial;

package/dist/graph/nodes/color/blend.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const blendNode: MaterialNodeDef;

package/dist/graph/nodes/color/bright-contrast.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const brightContrastNode: MaterialNodeDef;

package/dist/graph/nodes/color/hue-sat-val.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const hueSatValNode: MaterialNodeDef;

package/dist/graph/nodes/color/invert.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const invertNode: MaterialNodeDef;

package/dist/graph/nodes/color/rgb-curves.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const rgbCurvesNode: MaterialNodeDef;

package/dist/graph/nodes/converter/adapters.d.ts

@@ -0,0 +1,4 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const luminanceNode: MaterialNodeDef;
+export declare const splitChannelsNode: MaterialNodeDef;
+export declare const combineChannelsNode: MaterialNodeDef;

package/dist/graph/nodes/converter/clamp.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const clampNode: MaterialNodeDef;

package/dist/graph/nodes/converter/color-ramp.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const colorRampNode: MaterialNodeDef;

package/dist/graph/nodes/converter/height-blend.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const heightBlendNode: MaterialNodeDef;

package/dist/graph/nodes/converter/levels.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const levelsNode: MaterialNodeDef;

package/dist/graph/nodes/converter/math.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const mathNode: MaterialNodeDef;

package/dist/graph/nodes/converter/xyz.d.ts

@@ -0,0 +1,3 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const separateXyzNode: MaterialNodeDef;
+export declare const combineXyzNode: MaterialNodeDef;

package/dist/graph/nodes/group/group.d.ts

@@ -0,0 +1,4 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const groupNode: MaterialNodeDef;
+export declare const groupInputNode: MaterialNodeDef;
+export declare const groupOutputNode: MaterialNodeDef;

package/dist/graph/nodes/input/constant.d.ts

@@ -0,0 +1,3 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const constantFieldNode: MaterialNodeDef;
+export declare const constantColorNode: MaterialNodeDef;

package/dist/graph/nodes/input/tex-coordinate.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const texCoordNode: MaterialNodeDef;

package/dist/graph/nodes/output/material-output.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const materialOutputNode: MaterialNodeDef;

package/dist/graph/nodes/shader/emission.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const emissionNode: MaterialNodeDef;

package/dist/graph/nodes/shader/mix-shader.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const mixShaderNode: MaterialNodeDef;

package/dist/graph/nodes/shader/principled-bsdf.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const principledBsdfNode: MaterialNodeDef;

package/dist/graph/nodes/texture/anisotropic-stripes.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const anisotropicStripesNode: MaterialNodeDef;

package/dist/graph/nodes/texture/checker.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const checkerNode: MaterialNodeDef;

package/dist/graph/nodes/texture/fbm.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const fbmNode: MaterialNodeDef;

package/dist/graph/nodes/texture/gradient.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const gradientNode: MaterialNodeDef;

package/dist/graph/nodes/texture/scatter.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const scatterNode: MaterialNodeDef;

package/dist/graph/nodes/texture/screen-noise.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const screenNoiseNode: MaterialNodeDef;

package/dist/graph/nodes/texture/shape.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const shapeNode: MaterialNodeDef;

package/dist/graph/nodes/texture/tile.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const tileNode: MaterialNodeDef;

package/dist/graph/nodes/texture/tileable-noise.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const tileableNoiseNode: MaterialNodeDef;

package/dist/graph/nodes/texture/voronoi.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const voronoiNode: MaterialNodeDef;

package/dist/graph/nodes/texture/wave.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const waveNode: MaterialNodeDef;

package/dist/graph/nodes/vector/domain-warp.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const domainWarpNode: MaterialNodeDef;

package/dist/graph/nodes/vector/mapping.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const mappingNode: MaterialNodeDef;

package/dist/graph/nodes/vector/normal-from-height.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const normalFromHeightNode: MaterialNodeDef;

package/dist/graph/nodes/vector/normal-map.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const normalMapNode: MaterialNodeDef;

package/dist/graph/nodes/vector/tileable-warp.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const tileableWarpNode: MaterialNodeDef;

package/dist/graph/nodes/vector/vector-math.d.ts

@@ -0,0 +1,2 @@
+import type { MaterialNodeDef } from "../../types";
+export declare const vectorMathNode: MaterialNodeDef;

package/dist/graph/registry.d.ts

@@ -0,0 +1,15 @@
+import type { GraphNode, MaterialNodeDef, ParamDef, PortDef } from "./types";
+export declare function nodePorts(node: GraphNode, registry: NodeRegistry): {
+    inputs: PortDef[];
+    outputs: PortDef[];
+};
+export declare function nodeParamDefs(node: GraphNode, registry: NodeRegistry): ParamDef[];
+export declare class NodeRegistry {
+    private readonly defs;
+    register(def: MaterialNodeDef): this;
+    get(type: string): MaterialNodeDef;
+    has(type: string): boolean;
+    all(): MaterialNodeDef[];
+}
+export declare function createDefaultRegistry(): NodeRegistry;
+export declare const defaultRegistry: NodeRegistry;

package/dist/graph/textured-surface.d.ts

@@ -0,0 +1,60 @@
+import * as THREE from "three";
+import type { MeshStandardNodeMaterial } from "three/webgpu";
+import { type MaterialBackend, type MaterialGraphSource } from "./types";
+import { type MaterialBakeService } from "./bake-service";
+export declare class TexturedSurface {
+    private readonly graph;
+    private readonly service;
+    private readonly source?;
+    private readonly offlineMat;
+    private liveUniforms;
+    private material_;
+    readonly scaleUniform: import("three/webgpu").UniformNode<"float", number>;
+    readonly sharpnessUniform: import("three/webgpu").UniformNode<"float", number>;
+    readonly roughnessFactor: import("three/webgpu").UniformNode<"float", number>;
+    readonly metalnessFactor: import("three/webgpu").UniformNode<"float", number>;
+    readonly colorTint: import("three/webgpu").UniformNode<"color", THREE.Color>;
+    readonly parallaxScale: import("three/webgpu").UniformNode<"float", number>;
+    lastBakeMs: number;
+    private set;
+    private backend;
+    private debugNormals;
+    private triplanar;
+    private wiredOnce;
+    private lastPresent;
+    private updateInFlight;
+    private pendingKind;
+    private flushRequested;
+    private readonly listeners;
+    private lastError_;
+    constructor(graph: MaterialGraphSource, service: MaterialBakeService, source?: string | undefined);
+    get material(): MeshStandardNodeMaterial;
+    get lastError(): string | null;
+    getLastBakeMs(): number;
+    onRebuilt(fn: () => void): () => void;
+    private notify;
+    refresh(): Promise<void>;
+    regenerate(): void;
+    setScale(value: number): void;
+    setSharpness(value: number): void;
+    setRoughnessFactor(value: number): void;
+    setMetalnessFactor(value: number): void;
+    setColorTint(hex: string): void;
+    setParallaxScale(value: number): void;
+    setTriplanar(on: boolean): void;
+    setNormalDebug(on: boolean): void;
+    setBackend(backend: MaterialBackend): void;
+    getBackend(): MaterialBackend;
+    private onGraphChange;
+    private applyUniformValue;
+    private updateLiveUniform;
+    private updateOfflineUniform;
+    private requestUpdate;
+    private pump;
+    private rerenderOffline;
+    private surfaceBakeSize;
+    private rebuild;
+    private buildLive;
+    private wire;
+    dispose(): void;
+}

package/dist/graph/tiling-test.d.ts

@@ -0,0 +1,21 @@
+import type { MaterialBakeService } from "./bake-service";
+import type { NodeRegistry } from "./registry";
+import type { PbrSocket } from "./types";
+export interface SeamMetrics {
+    type: string;
+    ratioH: number;
+    ratioV: number;
+    wrapH: number;
+    wrapV: number;
+    interiorH: number;
+    interiorV: number;
+    pass: boolean;
+}
+export interface TilingTestOptions {
+    size?: number;
+    threshold?: number;
+    channel?: PbrSocket;
+    types?: string[];
+    onTile?: (type: string, img: ImageData) => void | Promise<void>;
+}
+export declare function runTilingTest(service: MaterialBakeService, registry: NodeRegistry, options?: TilingTestOptions): Promise<SeamMetrics[]>;

package/dist/graph/types.d.ts

@@ -0,0 +1,153 @@
+export type MaterialValue = any;
+export type PortKind = "float" | "vector" | "color" | "shader";
+export interface PortDef {
+    key: string;
+    label?: string;
+    kind: PortKind;
+}
+export type NodeClass = "input" | "output" | "shader" | "texture" | "color" | "vector" | "converter" | "group";
+export type ParamType = "float" | "int" | "bool" | "color" | "select" | "vec3" | "curve";
+export interface Vec3Value {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface CurveValue {
+    C: number[];
+    R: number[];
+    G: number[];
+    B: number[];
+}
+export declare const CURVE_IDENTITY: readonly number[];
+export declare const CURVE_CHANNELS: readonly ["C", "R", "G", "B"];
+export declare function curveToArray(v: CurveValue | undefined): number[];
+export interface ParamDef {
+    key: string;
+    label: string;
+    type: ParamType;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+    default: unknown;
+    bakeStructural?: boolean;
+}
+export type MaterialBackend = "live" | "offline";
+export type GraphChange = {
+    kind: "structural";
+} | {
+    kind: "layout";
+} | {
+    kind: "param";
+    nodeId: string;
+    key: string;
+    paramType: ParamType;
+    value: unknown;
+    bakeStructural?: boolean;
+};
+export interface BuildCtx {
+    inputs: Record<string, MaterialValue | undefined>;
+    uniforms: Record<string, MaterialValue>;
+    params: Record<string, unknown>;
+    coord: MaterialValue;
+    backend: MaterialBackend;
+    tileRepeat?: number;
+}
+export interface MaterialNodeDef {
+    type: string;
+    nodeClass: NodeClass;
+    label: string;
+    inputs: PortDef[];
+    outputs: PortDef[];
+    params: ParamDef[];
+    declare?(params: Record<string, unknown>): {
+        inputs: PortDef[];
+        outputs: PortDef[];
+    };
+    paramsFor?(params: Record<string, unknown>): ParamDef[];
+    bakeDerivative?: boolean;
+    bakeTileable?: boolean;
+    build(ctx: BuildCtx): Record<string, MaterialValue>;
+}
+export interface GraphNode {
+    id: string;
+    type: string;
+    params: Record<string, unknown>;
+    position?: {
+        x: number;
+        y: number;
+    };
+    enabled: boolean;
+    label?: string;
+    ports?: {
+        inputs: PortDef[];
+        outputs: PortDef[];
+    };
+    subgraph?: MaterialGraphDocument;
+}
+export declare const GROUP_TYPE = "group";
+export declare const GROUP_INPUT_TYPE = "group-input";
+export declare const GROUP_OUTPUT_TYPE = "group-output";
+export interface GraphEdge {
+    fromNode: string;
+    fromOutput: string;
+    toNode: string;
+    toInput: string;
+}
+export interface MaterialGraphDocument {
+    version: number;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    metadata?: MaterialGraphDocumentMetadata;
+    ui?: MaterialGraphDocumentUiState;
+}
+export interface MaterialGraphDocumentMetadata {
+    title?: string;
+}
+export interface MaterialGraphEditorViewState {
+    layoutArrangement?: "down" | "right" | "up" | "left";
+    transform?: {
+        k: number;
+        x: number;
+        y: number;
+    };
+}
+export interface MaterialGraphEditorUiState {
+    activeGroupPath?: string[];
+    soloNode?: string | null;
+    view?: MaterialGraphEditorViewState;
+}
+export interface MaterialGraphDocumentUiState {
+    editor?: MaterialGraphEditorUiState;
+    settings?: Record<string, unknown>;
+}
+export interface MaterialGraphSource {
+    readonly document: MaterialGraphDocument;
+    readonly lastError: string | null;
+    readonly soloNode: string | null;
+    compileBundle(opts: import("./compiler").CompileOptions): import("./compiler").CompiledSockets;
+    getRegistry(): import("./registry").NodeRegistry;
+    onChange(fn: (change: GraphChange) => void): () => void;
+}
+export declare const MATERIAL_OUTPUT_TYPE = "material-output";
+export declare const PBR_SOCKETS: readonly ["baseColor", "normal", "emission", "roughness", "metallic", "ambientOcclusion"];
+export type PbrSocket = (typeof PBR_SOCKETS)[number];
+export interface MaterialBundle {
+    baseColor?: MaterialValue;
+    metallic?: MaterialValue;
+    roughness?: MaterialValue;
+    ior?: MaterialValue;
+    alpha?: MaterialValue;
+    normal?: MaterialValue;
+    height?: MaterialValue;
+    ambientOcclusion?: MaterialValue;
+    emission?: MaterialValue;
+    coat?: MaterialValue;
+    coatRoughness?: MaterialValue;
+    sheen?: MaterialValue;
+    sheenRoughness?: MaterialValue;
+    transmission?: MaterialValue;
+}
+export type Coercion = "identity" | "float-to-vector" | "float-to-color" | "vector-to-float" | "vector-to-color" | "color-to-float" | "color-to-vector";
+export declare const COERCION_MATRIX: Record<PortKind, Partial<Record<PortKind, Coercion>>>;
+export declare function coercionFor(from: PortKind, to: PortKind): Coercion | undefined;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { MaterialGraphRuntime, type MaterialGraphRuntimeOptions } from "./runtime";
+export { MATERIAL_DOCUMENT_VERSION, MaterialGraphSession, cloneMaterialDocument, createDefaultMaterialDocument, migrateMaterialDocument, } from "./document";
+export { createMaterialTopologyKey } from "./topology";
+export { MaterialBakeService, BakedTextureSet, SURFACE_CHANNELS, bakeService, type BakeOptions, type BakeReport, } from "./graph/bake-service";
+export { compileGraph, compileSockets, countGraphNodes, newSurfaceMaterial, readOutputResolution, type CompileOptions, type CompiledSockets, } from "./graph/compiler";
+export { NodeRegistry, createDefaultRegistry, defaultRegistry, nodeParamDefs, nodePorts, } from "./graph/registry";
+export { TexturedSurface } from "./graph/textured-surface";
+export { runTilingTest } from "./graph/tiling-test";
+export * from "./graph/types";