material-designer-runtime 0.1.4 → 0.1.5

package/README.md

@@ -103,4 +103,170 @@ for PNG export, use `bakeService.readImage(session, channel, 1024)` → `ImageDa
 multiple of 64). If you keep a live `MaterialGraphRuntime`, the same baked textures are also
 reachable via `runtime.surface.getChannelTexture(channel)` and `runtime.surface.getHeightTexture()`.
 
-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.
+## Persistent texture cache (opt-in)
+
+Baking is dominated by **shader compilation**, not rendering — on a heavy graph the pipeline compile runs
+into seconds while the render is tens of milliseconds. Without a cache that cost is paid again on every page
+load, even when the document hasn't changed by a single texel.
+
+The cache stores the baked channel texels and, on a hit, restores them with a GPU-to-GPU copy that
+short-circuits **before** the compile. It is **off by default** — enabling it is the only way anything is
+persisted:
+
+```ts
+const runtime = new MaterialGraphRuntime({ document, cache: {} }); // {} = defaults, enabled
+// …or turn it on later:
+runtime.setCacheEnabled(true);
+```
+
+Everything you need:
+
+```ts
+runtime.cacheEnabled;                      // is it on?
+runtime.setCacheEnabled(true | false);     // toggle (installs the default cache on first enable)
+await runtime.clearCache();                // drop every cached bake
+await runtime.rebuildCache();              // re-bake for real and replace this document's entry,
+                                           //   resolving only once the new entry is durably written
+await runtime.getCachedTextures();         // this document's entry metadata, or null
+await runtime.listCachedTextures();        // every entry's metadata, newest use first
+await runtime.loadCachedChannelTextures(); // …or the actual textures (see below)
+await runtime.cacheMetrics();              // size taken + hit/miss/evict counters
+await runtime.flushCache();                // force the deferred write now (e.g. on unload)
+```
+
+`cacheMetrics()` answers "how much space is this taking":
+
+```ts
+{ enabled, available, store: "worker-indexeddb", encoding: "png",
+  entries, bytes,            // bytes AS STORED (post-compression) — the real footprint
+  budgetBytes,               // LRU-evicted down to this
+  hits, misses, writes, evictions, collisions,
+  quota: { usage, quota },   // navigator.storage.estimate(), where the browser reports it
+  lastError }
+```
+
+### Configuration
+
+```ts
+new MaterialGraphRuntime({ document, cache: {
+  enabled: true,
+  store: myStore,           // bring your own (see below); default is worker+IndexedDB
+  encoding: "deflate",      // or "rgba8" (cheaper saves) / "png" (smallest, slower restores)
+  budgetBytes: 256 * 2 ** 20,   // on-disk ceiling, in STORED (compressed) bytes
+  maxEntryBytes: 256 * 2 ** 20, // per-capture ceiling, in RAW texel bytes — see note below
+  minBakeMs: 250,           // don't spend disk to save a bake cheaper than this
+  writeDelayMs: 750,        // quiet period before the capture runs
+  worker: true,             // false = main thread; { url } = self-hosted worker (strict CSP)
+  namespace: "my-app",      // your own invalidation lever
+  onEvent: (e) => {},       // hit | miss | write | evict | collision | disabled | error
+}});
+```
+
+The codec and all storage IO run **in a worker**, so neither encoding nor IO touches the main thread. Only the
+GPU readback is main-thread (it has to be), and it is deferred past `writeDelayMs`, skipped when an entry
+already exists, and collapsed to one capture per burst of re-bakes.
+
+**On `encoding`.** All three options are lossless; they trade save cost against footprint.
+
+- `"deflate"` (default) — byte compression, no image codec. Restores as fast as raw texels, and stores about
+  6× smaller. Saving costs real CPU, but it runs in the worker and does not hold the bake queue, so nothing
+  waits on it.
+- `"rgba8"` — raw texels. Cheapest to save, largest on disk.
+- `"png"` — smallest footprint, but measurably slower to restore: unpacking an image is real work, and a
+  cache exists to make the second load fast.
+
+Footprint matters more than it first looks. Raw texels run ~80 MB per material at 2048², so the default
+256 MB budget would hold roughly three materials before evicting; compressed it holds around eighteen. That is
+the difference between a cache that accumulates and one that thrashes.
+
+Lossy GPU formats (KTX2/Basis) are deliberately not offered. This cache must reproduce a bake *exactly* —
+otherwise you would author a material against one image and get a different one back on reload — and block
+compression visibly damages the data channels, normals worst of all. It would also buy nothing here: a restore
+writes into the same render targets the baker draws into, and those are uncompressed by construction.
+
+**The two size knobs are in different currencies.** `budgetBytes` is compressed bytes on disk.
+`maxEntryBytes` is *raw* texel bytes, because it gates the capture before the readback — at which point the
+stored size can't be known. Size it against raw totals:
+
+| bake size | 1 channel | 7 channels (raw) |
+| --- | --- | --- |
+| 512²  | 1 MB  | 7 MB |
+| 1024² | 4 MB  | 28 MB |
+| 2048² | 16 MB | 112 MB |
+| 4096² | 64 MB | 448 MB |
+
+PNG typically shrinks that by 10× or more, so if you set `maxEntryBytes` to the on-disk figure you have in
+mind, larger materials will silently stop being cached.
+
+### What a capture costs
+
+The readback is the one part that runs on the main thread. Measured on an M-series Mac in Chrome, per
+channel, median of 12 runs:
+
+| bake size | GPU→CPU read | row flip (JS) | total | ×7 channels |
+| --- | --- | --- | --- | --- |
+| 512²  | 1.0 ms  | 0.2 ms | 1.2 ms  | ~8 ms |
+| 1024² | 2.4 ms  | 0.6 ms | 3.0 ms  | ~21 ms |
+| 2048² | 6.3 ms  | 2.4 ms | 8.7 ms  | ~61 ms |
+| 4096² | 22.3 ms | 9.9 ms | 32.2 ms | ~225 ms |
+
+Roughly linear in bytes (~0.35 ms/MB transfer, ~0.15 ms/MB flip). This is why the capture is deferred rather
+than run inline at the end of a bake: it is work that only pays off on the *next* load, so making the current
+one wait for it would be paying now for a benefit later. De-padding is free at bake sizes that are multiples
+of 64 (the rows arrive tightly packed), which every surface bake is.
+
+### Bring your own storage
+
+Implement `BakeCacheStore` and the runtime uses it instead of IndexedDB — for a server, a CDN, your own
+database, or node's filesystem:
+
+```ts
+import { BakeTextureCache, type BakeCacheStore } from "material-designer-runtime";
+
+const store: BakeCacheStore = {
+  name: "my-backend",
+  async get(id) { … }, async put(entry) { … },
+  async touch(id, lastUsedAt) { … },   // must NOT rewrite the texels — runs on every hit
+  async delete(id) { … },
+  async list() { … },                  // metadata ONLY, never texels
+  async clear() { … },
+};
+runtime.service.setCache(new BakeTextureCache({ enabled: true, store }));
+```
+
+Texels cross this interface as tightly-packed, top-down RGBA8; compress internally if you like, but decode
+before returning, and overwrite `meta.bytes` with the size you actually stored so the metrics stay truthful.
+`createBakeCacheKey(...)` (also `runtime.cacheKey()`) is exported, so you can key your own cache identically.
+
+### Using cached textures directly
+
+`loadCachedChannelTextures()` needs **no renderer** — a page shipping a fixed material can dress a plain
+THREE material from cache without ever compiling a shader:
+
+```ts
+const cached = await runtime.loadCachedChannelTextures();
+if (cached) {
+  const material = buildMeshMaterial(runtime.getDocument(), cached);
+  // …you own these textures: cached.dispose() when the material is done with them.
+}
+```
+
+### Notes
+
+- **Invalidation is automatic.** The key covers the graph topology, every effective param value (registry
+  defaults merged in, so a sparse document keys the same as an explicit one), bake size, channel set, document
+  schema version, three's revision, and this package's version — the last because node maths changes texel
+  output without a schema bump. An upgrade therefore starts cold rather than restoring stale texels.
+  Cosmetics (node labels, positions, pan/zoom, metadata) never invalidate.
+- **A cache failure can never break a bake.** Every storage call is contained; a miss, a corrupt record, a
+  dead worker, or an exhausted quota all fall through to baking normally.
+- **The first edit after a hit costs one full rebuild.** A restore deliberately skips compilation, so there are
+  no compiled materials to re-render with until the next rebuild repopulates them.
+- **It is a binary store, so `localStorage.clear()` will not touch it.** If your app has a "reset everything"
+  path, call `clearCache()` there too; `BAKE_CACHE_DB_NAME` is exported if you'd rather delete the database.
+
+The editor owns UI state, selection, presets, and undo history. This package owns graph document loading,
+compilation, baking, direct parameter updates, the material surface, and — opt-in — a cache of its own bake
+artifacts. That last one is the single exception to "the editor owns storage": it caches only what this package
+produces, it is off unless you enable it, and `cache.store` hands storage ownership back to you whenever you
+want it.

package/dist/cache/bake-cache.d.ts

@@ -0,0 +1,45 @@
+import { type BakeCacheKey } from "./key";
+import type { BakeCacheEntry, BakeCacheEntryMeta, BakeCacheMetrics, BakeCacheOptions, BakeCachePayload } from "./types";
+export declare class BakeTextureCache {
+    private store;
+    private ownsStore;
+    private enabled_;
+    private options;
+    private onEvent;
+    private workerOption;
+    private hits;
+    private misses;
+    private writes;
+    private evictions;
+    private collisions;
+    private lastError_;
+    private quotaFailures;
+    private gcDone;
+    constructor(options?: BakeCacheOptions);
+    get enabled(): boolean;
+    get available(): boolean;
+    get storeName(): string;
+    get encoding(): BakeCacheOptions["encoding"];
+    get namespace(): string;
+    get writeDelayMs(): number;
+    get lastError(): string | null;
+    setEnabled(on: boolean): void;
+    configure(patch: BakeCacheOptions): void;
+    read(key: BakeCacheKey): Promise<BakeCacheEntry | null>;
+    peek(key: BakeCacheKey): Promise<BakeCacheEntryMeta | null>;
+    entries(): Promise<BakeCacheEntryMeta[]>;
+    canWrite(bakeMs: number, bytes: number): boolean;
+    write(key: BakeCacheKey, payload: BakeCachePayload): Promise<void>;
+    delete(key: BakeCacheKey | string): Promise<void>;
+    clear(): Promise<void>;
+    gc(): Promise<number>;
+    evict(): Promise<number>;
+    metrics(): Promise<BakeCacheMetrics>;
+    info(): Record<string, unknown>;
+    private put;
+    private evictTo;
+    private ensureGc;
+    private guard;
+    private fail;
+    private emit;
+}

package/dist/cache/cache.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cache/codec.d.ts

@@ -0,0 +1,13 @@
+import type { BakeCacheEncoding } from "./types";
+export declare function canEncodePng(): boolean;
+export declare function encodePng(texels: Uint8Array, size: number): Promise<Uint8Array>;
+export declare function decodePng(bytes: Uint8Array, size: number): Promise<Uint8Array>;
+export declare function canDeflate(): boolean;
+export declare function deflateBytes(bytes: Uint8Array): Promise<Uint8Array>;
+export declare function inflateBytes(bytes: Uint8Array): Promise<Uint8Array>;
+export declare function encodeTexels(texels: Uint8Array, size: number, encoding: BakeCacheEncoding): Promise<{
+    bytes: Uint8Array;
+    encoding: BakeCacheEncoding;
+}>;
+export declare function decodeTexels(bytes: Uint8Array, size: number, encoding: BakeCacheEncoding): Promise<Uint8Array>;
+export declare function pngRoundTripIsLossless(size?: number): Promise<boolean>;

package/dist/cache/idb-core.d.ts

@@ -0,0 +1,27 @@
+import type { BakeCacheChannel, BakeCacheEncoding, BakeCacheEntryMeta } from "./types";
+export declare const BAKE_CACHE_DB_NAME = "material-designer-textures";
+export declare const BAKE_CACHE_DB_VERSION = 1;
+export declare const META_STORE = "meta";
+export declare const DATA_STORE = "data";
+export interface StoredTexels {
+    channel: BakeCacheChannel;
+    encoding: BakeCacheEncoding;
+    bytes: ArrayBuffer;
+}
+export interface StoredData {
+    id: string;
+    textures: StoredTexels[];
+}
+export declare function isIndexedDbAvailable(): boolean;
+export declare function dbNameFor(namespace: string): string;
+export declare function openBakeCacheDb(dbName: string): Promise<IDBDatabase>;
+export declare function idbGet(db: IDBDatabase, id: string): Promise<{
+    meta: BakeCacheEntryMeta;
+    data: StoredData;
+} | null>;
+export declare function idbPut(db: IDBDatabase, meta: BakeCacheEntryMeta, data: StoredData): Promise<void>;
+export declare function idbTouch(db: IDBDatabase, id: string, lastUsedAt: number): Promise<void>;
+export declare function idbDelete(db: IDBDatabase, id: string): Promise<void>;
+export declare function idbList(db: IDBDatabase): Promise<BakeCacheEntryMeta[]>;
+export declare function idbClear(db: IDBDatabase): Promise<void>;
+export declare function toStandaloneBuffer(bytes: Uint8Array): ArrayBuffer;

package/dist/cache/index.d.ts

@@ -0,0 +1,7 @@
+export { BakeTextureCache } from "./bake-cache";
+export { createMemoryCacheStore } from "./memory-store";
+export { BAKE_CACHE_DB_NAME, BAKE_CACHE_DB_VERSION, createDefaultCacheStore, createIndexedDbCacheStore, isIndexedDbAvailable, type DefaultCacheStoreOptions, type IndexedDbCacheStoreOptions, } from "./indexeddb-store";
+export { createWorkerCacheStore, isWorkerCacheAvailable, type WorkerCacheStoreOptions, } from "./worker-client";
+export { canDeflate, canEncodePng, decodeTexels, deflateBytes, encodeTexels, inflateBytes, pngRoundTripIsLossless, } from "./codec";
+export { BAKE_CACHE_ID_PREFIX, BAKE_CACHE_SCHEMA, BAKE_CACHE_VERSION, BAKE_ENCODER_VERSION, createBakeCacheKey, fnv1a64, type BakeCacheKey, type BakeCacheKeyInput, } from "./key";
+export type { BakeCacheChannel, BakeCacheEncoding, BakeCacheEntry, BakeCacheEntryMeta, BakeCacheEvent, BakeCacheEventKind, BakeCacheMetrics, BakeCacheOptions, BakeCachePayload, BakeCacheStore, BakeCacheStoreEstimate, BakeCacheTexels, } from "./types";

package/dist/cache/indexeddb-store.d.ts

@@ -0,0 +1,13 @@
+import type { BakeCacheEncoding, BakeCacheStore } from "./types";
+export { BAKE_CACHE_DB_NAME, BAKE_CACHE_DB_VERSION, isIndexedDbAvailable, } from "./idb-core";
+export interface IndexedDbCacheStoreOptions {
+    namespace?: string;
+    encoding?: BakeCacheEncoding;
+}
+export declare function createIndexedDbCacheStore(options?: IndexedDbCacheStoreOptions): BakeCacheStore;
+export interface DefaultCacheStoreOptions extends IndexedDbCacheStoreOptions {
+    worker?: boolean | {
+        url: string | URL;
+    };
+}
+export declare function createDefaultCacheStore(options?: DefaultCacheStoreOptions): BakeCacheStore;

package/dist/cache/key.d.ts

@@ -0,0 +1,21 @@
+import type { NodeRegistry } from "../graph/registry";
+import type { MaterialGraphDocument } from "../graph/types";
+import type { BakeCacheChannel } from "./types";
+export declare const BAKE_CACHE_VERSION = 1;
+export declare const BAKE_ENCODER_VERSION = 1;
+export declare const BAKE_CACHE_ID_PREFIX: string;
+export declare const BAKE_CACHE_SCHEMA: string;
+export interface BakeCacheKeyInput {
+    document: MaterialGraphDocument;
+    registry: NodeRegistry;
+    size: number;
+    channels: readonly BakeCacheChannel[];
+    backend?: string;
+    namespace?: string;
+}
+export interface BakeCacheKey {
+    id: string;
+    key: string;
+}
+export declare function fnv1a64(text: string): string;
+export declare function createBakeCacheKey(input: BakeCacheKeyInput): BakeCacheKey;

package/dist/cache/memory-store.d.ts

@@ -0,0 +1,2 @@
+import type { BakeCacheStore } from "./types";
+export declare function createMemoryCacheStore(): BakeCacheStore;

package/dist/cache/types.d.ts

@@ -0,0 +1,85 @@
+import type { PbrSocket } from "../graph/types";
+export type BakeCacheChannel = PbrSocket | "height";
+export type BakeCacheEncoding = "png" | "rgba8" | "deflate";
+export interface BakeCacheTexels {
+    channel: BakeCacheChannel;
+    encoding: BakeCacheEncoding;
+    bytes: Uint8Array;
+}
+export interface BakeCacheEntryMeta {
+    id: string;
+    key: string;
+    schema: string;
+    size: number;
+    encoding: BakeCacheEncoding;
+    channels: BakeCacheChannel[];
+    hasHeight: boolean;
+    bytes: number;
+    bakeMs: number;
+    createdAt: number;
+    lastUsedAt: number;
+}
+export interface BakeCacheEntry extends BakeCacheEntryMeta {
+    textures: BakeCacheTexels[];
+}
+export interface BakeCachePayload {
+    size: number;
+    channels: BakeCacheChannel[];
+    hasHeight: boolean;
+    bakeMs: number;
+    textures: BakeCacheTexels[];
+}
+export interface BakeCacheStoreEstimate {
+    entries: number;
+    bytes: number;
+}
+export interface BakeCacheStore {
+    readonly name: string;
+    get(id: string): Promise<BakeCacheEntry | null>;
+    put(entry: BakeCacheEntry): Promise<void>;
+    touch(id: string, lastUsedAt: number): Promise<void>;
+    delete(id: string): Promise<void>;
+    list(): Promise<BakeCacheEntryMeta[]>;
+    clear(): Promise<void>;
+    estimate?(): Promise<BakeCacheStoreEstimate>;
+}
+export type BakeCacheEventKind = "hit" | "miss" | "write" | "evict" | "collision" | "disabled" | "error";
+export interface BakeCacheEvent {
+    kind: BakeCacheEventKind;
+    id?: string;
+    bytes?: number;
+    message?: string;
+}
+export interface BakeCacheOptions {
+    enabled?: boolean;
+    store?: BakeCacheStore;
+    encoding?: BakeCacheEncoding;
+    budgetBytes?: number;
+    maxEntryBytes?: number;
+    minBakeMs?: number;
+    writeDelayMs?: number;
+    worker?: boolean | {
+        url: string | URL;
+    };
+    namespace?: string;
+    onEvent?: (event: BakeCacheEvent) => void;
+}
+export interface BakeCacheMetrics {
+    enabled: boolean;
+    available: boolean;
+    store: string;
+    encoding: BakeCacheEncoding;
+    entries: number;
+    bytes: number;
+    budgetBytes: number;
+    hits: number;
+    misses: number;
+    writes: number;
+    evictions: number;
+    collisions: number;
+    quota: {
+        usage: number;
+        quota: number;
+    } | null;
+    lastError: string | null;
+}

package/dist/cache/worker-client.d.ts

@@ -0,0 +1,8 @@
+import type { BakeCacheEncoding, BakeCacheStore } from "./types";
+export interface WorkerCacheStoreOptions {
+    namespace?: string;
+    encoding?: BakeCacheEncoding;
+    url?: string | URL;
+}
+export declare function isWorkerCacheAvailable(): boolean;
+export declare function createWorkerCacheStore(options?: WorkerCacheStoreOptions): BakeCacheStore | null;

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

@@ -1,6 +1,9 @@
 import * as THREE from "three";
 import { RenderTarget, type WebGPURenderer, type MeshBasicNodeMaterial } from "three/webgpu";
 import { type CacheEntry, type ParamUsage } from "./compiler";
+import type { BakeTextureCache } from "../cache/bake-cache";
+import { type BakeCacheKey } from "../cache/key";
+import type { BakeCacheChannel, BakeCacheMetrics } from "../cache/types";
 import { type NodeProfileOptions, type NodeProfileReport } from "./node-profiler";
 import type { MaterialGraphSource, MaterialValue, PbrSocket } from "./types";
 export declare const SURFACE_CHANNELS: PbrSocket[];
@@ -10,11 +13,12 @@ export interface BakeOptions {
     soloNodeId?: string;
     label?: string;
     source?: string;
+    bypassCache?: boolean;
 }
 export interface BakeReport {
     runId: number;
     source: string | undefined;
-    phase: "nodes" | "shaders" | "render" | "done";
+    phase: "nodes" | "shaders" | "render" | "restore" | "done";
     nodeCount: number;
     compileMs: number;
     texturesTotal: number;
@@ -34,6 +38,10 @@ export declare class BakedTextureSet {
     hasHeight: boolean;
     present: Set<"roughness" | "normal" | "baseColor" | "metallic" | "ambientOcclusion" | "emission">;
     signature: string;
+    restored: boolean;
+    contentStamp: number;
+    lastRebuildMs: number;
+    disposed: boolean;
     size: number;
     constructor(size: number, channels: PbrSocket[]);
     resize(size: number): void;
@@ -46,6 +54,7 @@ export declare class BakedTextureSet {
     firstTarget(): RenderTarget | null;
     ensureHeightTarget(): RenderTarget;
     texture(ch: PbrSocket): THREE.Texture | null;
+    setPresence(present: Set<PbrSocket>, hasHeight: boolean): boolean;
     allocConstantArray(nodeId: string, key: string, data: ArrayLike<number>, elementType: "float" | "vec3"): MaterialValue;
     debugCounts(): Record<string, number>;
     flushCaches(): void;
@@ -71,6 +80,9 @@ export declare class MaterialBakeService {
     private scratchSize;
     private readonly scratchCaches;
     private scratchCacheSize;
+    private cache_;
+    private readonly pendingWrites;
+    private readonly pendingStores;
     attachRenderer(renderer: WebGPURenderer): void;
     get hasRenderer(): boolean;
     onProgress(cb: (p: BakeProgress) => void): () => void;
@@ -85,6 +97,14 @@ export declare class MaterialBakeService {
     bake(graph: MaterialGraphSource, opts?: BakeOptions): Promise<BakedTextureSet>;
     readImage(graph: MaterialGraphSource, channel: PbrSocket, size?: number): Promise<ImageData | null>;
     gpuInfo(): Record<string, unknown>;
+    setCache(cache: BakeTextureCache | null): void;
+    get cache(): BakeTextureCache | null;
+    cacheMetrics(): Promise<BakeCacheMetrics | null>;
+    cacheKeyFor(graph: MaterialGraphSource, size: number, channels?: readonly BakeCacheChannel[]): BakeCacheKey;
+    private tryRestoreFromCache;
+    scheduleCacheWrite(set: BakedTextureSet, graph: MaterialGraphSource, opts?: BakeOptions): void;
+    flushCacheWrites(): Promise<void>;
+    private runCacheWrite;
     private scratchTarget;
     profileNodes(graph: MaterialGraphSource, opts?: NodeProfileOptions): Promise<NodeProfileReport>;
     private scratchCache;

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

@@ -1,10 +1,13 @@
 import { RenderTarget, MeshBasicNodeMaterial, type WebGPURenderer } from "three/webgpu";
+import { type Texture } from "three";
 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 ssPoolInfo(): string[];
 export declare function makeChannelMaterial(): MeshBasicNodeMaterial;
+export declare function configureChannelTexture(t: Texture, ch: PbrSocket | "height"): void;
+export declare const MAX_ANISOTROPY = 8;
 export declare function compileMaterialsAsync(renderer: WebGPURenderer, materials: MeshBasicNodeMaterial[], destSize: number): 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;

package/dist/graph/texture-transfer.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import type { RenderTarget, WebGPURenderer } from "three/webgpu";
+import type { PbrSocket } from "./types";
+export declare function channelByteLength(size: number): number;
+export declare function paddedBytesPerRow(width: number): number;
+export declare function depadRows(buffer: Uint8Array, width: number, height: number): Uint8Array;
+export declare function flipRows(buffer: Uint8Array, width: number, height: number): Uint8Array;
+export declare function flipRowsInto(buffer: Uint8Array, out: Uint8Array, width: number, height: number): void;
+export declare function readTargetTexels(renderer: WebGPURenderer, rt: RenderTarget): Promise<Uint8Array>;
+export declare function transferPoolInfo(): string[];
+export declare function disposeTransferPool(): void;
+export declare function channelDataTexture(texels: Uint8Array, size: number, channel: PbrSocket | "height"): THREE.DataTexture;
+export declare function writeTargetTexels(renderer: WebGPURenderer, rt: RenderTarget, texels: Uint8Array): void;

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

@@ -24,6 +24,7 @@ export declare class TexturedSurface {
     private updateInFlight;
     private pendingKind;
     private flushRequested;
+    private bypassCacheOnce;
     private readonly listeners;
     private readonly textureListeners;
     private lastError_;
@@ -63,6 +64,7 @@ export declare class TexturedSurface {
     private pump;
     private rerenderOffline;
     private surfaceBakeSize;
+    get bakeSize(): number;
     private rebuild;
     private buildLive;
     private wire;

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-export { MaterialGraphRuntime, type MaterialGraphRuntimeOptions } from "./runtime";
+export { MaterialGraphRuntime, type CachedChannelTextures, type MaterialGraphRuntimeOptions, } from "./runtime";
 export { MATERIAL_DOCUMENT_VERSION, MaterialGraphSession, cloneMaterialDocument, createDefaultMaterialDocument, migrateMaterialDocument, } from "./document";
-export { createMaterialTopologyKey } from "./topology";
+export { MATERIAL_RUNTIME_VERSION } from "./version";
+export { canonicalStringify, createMaterialParamKey, createMaterialTopologyKey } from "./topology";
+export * from "./cache";
 export { MaterialBakeService, BakedTextureSet, SURFACE_CHANNELS, bakeService, type BakeOptions, type BakeReport, } from "./graph/bake-service";
 export { type NodeProfileOptions, type NodeProfileReport, type NodeProfileRow, } from "./graph/node-profiler";
 export { compileGraph, compileSockets, countGraphNodes, newSurfaceMaterial, readMaterialSurface, readMaterialConfig, readOutputResolution, type CompileOptions, type CompiledSockets, type MaterialConfig, } from "./graph/compiler";
 export { buildMeshMaterial, type ChannelTextures } from "./graph/mesh-material";
+export { channelByteLength, channelDataTexture, depadRows, disposeTransferPool, flipRows, paddedBytesPerRow, readTargetTexels, transferPoolInfo, writeTargetTexels, } from "./graph/texture-transfer";
 export { NodeRegistry, createDefaultRegistry, defaultRegistry, nodeParamDefs, nodePorts, } from "./graph/registry";
 export { TexturedSurface } from "./graph/textured-surface";
 export { runTilingTest } from "./graph/tiling-test";