@stevejtrettel/shader-sandbox 0.1.2 → 0.1.4

package/dist-lib/project/loadProject.js

@@ -1,13 +1,15 @@
 /**
- * Project Layer - Config Loader
+ * Project Layer - Config Loader (Node/CLI)
  *
- * Loads Shadertoy projects from disk into normalized ShadertoyProject representation.
+ * Loads shader projects from disk into normalized ShaderProject representation.
  * Handles both single-pass (no config) and multi-pass (with config) projects.
  *
  * Based on docs/project-spec.md
  */
 import { promises as fs } from 'fs';
 import * as path from 'path';
+import { isArrayUniform, } from './types';
+import { isPassName, parseChannelValue, defaultSourceForPass, validateConfig, CHANNEL_KEYS, BUFFER_PASS_NAMES, DEFAULT_LAYOUT, DEFAULT_CONTROLS, DEFAULT_THEME, } from './configHelpers';
 // =============================================================================
 // Helper Functions
 // =============================================================================
@@ -23,12 +25,6 @@ async function fileExists(p) {
         return false;
     }
 }
-/**
- * Type guard for PassName.
- */
-function isPassName(s) {
-    return s === 'Image' || s === 'BufferA' || s === 'BufferB' || s === 'BufferC' || s === 'BufferD';
-}
 /**
  * List all .glsl files in a directory.
  */
@@ -49,41 +45,40 @@ async function hasTexturesDirWithFiles(root) {
     return entries.some((e) => e.isFile());
 }
 /**
- * Get default source file name for a pass.
+ * Resolve common source from config or default common.glsl.
  */
-function defaultSourceForPass(name) {
-    switch (name) {
-        case 'Image':
-            return 'image.glsl';
-        case 'BufferA':
-            return 'bufferA.glsl';
-        case 'BufferB':
-            return 'bufferB.glsl';
-        case 'BufferC':
-            return 'bufferC.glsl';
-        case 'BufferD':
-            return 'bufferD.glsl';
+async function resolveCommonSource(root, commonField) {
+    if (commonField) {
+        const commonPath = path.join(root, commonField);
+        if (!(await fileExists(commonPath))) {
+            throw new Error(`Common GLSL file '${commonField}' not found in '${root}'.`);
+        }
+        return await fs.readFile(commonPath, 'utf8');
+    }
+    const defaultCommonPath = path.join(root, 'common.glsl');
+    if (await fileExists(defaultCommonPath)) {
+        return await fs.readFile(defaultCommonPath, 'utf8');
     }
+    return null;
 }
 // =============================================================================
 // Main Entry Point
 // =============================================================================
 /**
- * Load a Shadertoy project from disk.
+ * Load a shader project from disk.
  *
  * Automatically detects:
  * - Single-pass mode (no config, just image.glsl)
  * - Multi-pass mode (config.json present)
  *
  * @param root - Absolute path to project directory
- * @returns Fully normalized ShadertoyProject
+ * @returns Fully normalized ShaderProject
  * @throws Error with descriptive message if project is invalid
  */
 export async function loadProject(root) {
     const configPath = path.join(root, 'config.json');
     const hasConfig = await fileExists(configPath);
     if (hasConfig) {
-        // Multi-pass mode: parse config
         const raw = await fs.readFile(configPath, 'utf8');
         let config;
         try {
@@ -92,10 +87,13 @@ export async function loadProject(root) {
         catch (err) {
             throw new Error(`Invalid JSON in config.json at '${root}': ${err?.message ?? String(err)}`);
         }
-        return await loadProjectWithConfig(root, config);
+        validateConfig(config, root);
+        if (config.mode === 'shadertoy') {
+            return await loadShadertoyProject(root, config);
+        }
+        return await loadStandardProject(root, config);
     }
     else {
-        // Single-pass mode: just image.glsl
         return await loadSinglePassProject(root);
     }
 }
@@ -110,37 +108,31 @@ export async function loadProject(root) {
  * - Cannot have other .glsl files
  * - Cannot have textures/ directory
  * - No common.glsl allowed
- *
- * @param root - Project directory
- * @returns ShadertoyProject with only Image pass
  */
 async function loadSinglePassProject(root) {
     const imagePath = path.join(root, 'image.glsl');
     if (!(await fileExists(imagePath))) {
         throw new Error(`Single-pass project at '${root}' requires 'image.glsl'.`);
     }
-    // Check for extra GLSL files
     const glslFiles = await listGlslFiles(root);
     const extraGlsl = glslFiles.filter((name) => name !== 'image.glsl');
     if (extraGlsl.length > 0) {
         throw new Error(`Project at '${root}' contains multiple GLSL files (${glslFiles.join(', ')}) but no 'config.json'. Add a config file to use multiple passes.`);
     }
-    // Check for textures
     if (await hasTexturesDirWithFiles(root)) {
         throw new Error(`Project at '${root}' uses textures (in 'textures/' folder) but has no 'config.json'. Add a config file to define texture bindings.`);
     }
-    // Load shader source
     const imageSource = await fs.readFile(imagePath, 'utf8');
     const title = path.basename(root);
-    const project = {
+    return {
+        mode: 'standard',
         root,
-        meta: {
-            title,
-            author: null,
-            description: null,
-        },
-        layout: 'default',
-        controls: false,
+        meta: { title, author: null, description: null },
+        layout: DEFAULT_LAYOUT,
+        theme: DEFAULT_THEME,
+        controls: DEFAULT_CONTROLS,
+        startPaused: false,
+        pixelRatio: null,
         commonSource: null,
         passes: {
             Image: {
@@ -155,45 +147,85 @@ async function loadSinglePassProject(root) {
             },
         },
         textures: [],
+        uniforms: {},
+        script: null,
     };
-    return project;
 }
 // =============================================================================
-// Multi-Pass Mode (With Config)
+// Uniform Validation
 // =============================================================================
-/**
- * Parse a channel value (string shorthand or object) into normalized ChannelJSONObject.
- *
- * String shortcuts:
- * - "BufferA", "BufferB", etc. → buffer reference
- * - "keyboard" → keyboard input
- * - "photo.jpg" (with extension) → texture file
- */
-function parseChannelValue(value) {
-    if (typeof value === 'string') {
-        // Check for buffer names
-        if (isPassName(value)) {
-            return { buffer: value };
+const SCALAR_TYPES = new Set(['float', 'int', 'bool', 'vec2', 'vec3', 'vec4']);
+const ARRAY_TYPES = new Set(['float', 'vec2', 'vec3', 'vec4', 'mat3', 'mat4']);
+const COMPONENT_COUNTS = {
+    vec2: 2, vec3: 3, vec4: 4,
+};
+function validateUniforms(uniforms, root) {
+    for (const [name, def] of Object.entries(uniforms)) {
+        const prefix = `Uniform '${name}' in '${root}'`;
+        if (!def.type) {
+            throw new Error(`${prefix}: missing 'type' field`);
+        }
+        if (isArrayUniform(def)) {
+            if (!ARRAY_TYPES.has(def.type)) {
+                throw new Error(`${prefix}: invalid array type '${def.type}'. Expected one of: ${[...ARRAY_TYPES].join(', ')}`);
+            }
+            if (typeof def.count !== 'number' || def.count < 1 || !Number.isInteger(def.count)) {
+                throw new Error(`${prefix}: 'count' must be a positive integer, got ${def.count}`);
+            }
+            continue;
+        }
+        if (!SCALAR_TYPES.has(def.type)) {
+            throw new Error(`${prefix}: invalid type '${def.type}'. Expected one of: ${[...SCALAR_TYPES].join(', ')}`);
         }
-        // Check for keyboard
-        if (value === 'keyboard') {
-            return { keyboard: true };
+        switch (def.type) {
+            case 'float':
+            case 'int':
+                if (typeof def.value !== 'number') {
+                    throw new Error(`${prefix}: 'value' must be a number for type '${def.type}', got ${typeof def.value}`);
+                }
+                if (def.min !== undefined && typeof def.min !== 'number') {
+                    throw new Error(`${prefix}: 'min' must be a number`);
+                }
+                if (def.max !== undefined && typeof def.max !== 'number') {
+                    throw new Error(`${prefix}: 'max' must be a number`);
+                }
+                if (def.step !== undefined && typeof def.step !== 'number') {
+                    throw new Error(`${prefix}: 'step' must be a number`);
+                }
+                break;
+            case 'bool':
+                if (typeof def.value !== 'boolean') {
+                    throw new Error(`${prefix}: 'value' must be a boolean for type 'bool', got ${typeof def.value}`);
+                }
+                break;
+            case 'vec2':
+            case 'vec3':
+            case 'vec4': {
+                const n = COMPONENT_COUNTS[def.type];
+                if (!Array.isArray(def.value) || def.value.length !== n) {
+                    throw new Error(`${prefix}: 'value' must be an array of ${n} numbers for type '${def.type}'`);
+                }
+                if (def.value.some((v) => typeof v !== 'number')) {
+                    throw new Error(`${prefix}: all components of 'value' must be numbers`);
+                }
+                const vecDef = def;
+                for (const field of ['min', 'max', 'step']) {
+                    const arr = vecDef[field];
+                    if (arr !== undefined) {
+                        if (!Array.isArray(arr) || arr.length !== n) {
+                            throw new Error(`${prefix}: '${field}' must be an array of ${n} numbers for type '${def.type}'`);
+                        }
+                    }
+                }
+                break;
+            }
         }
-        // Assume texture (file path)
-        return { texture: value };
     }
-    // Already an object
-    return value;
 }
-/**
- * Load a project with config.json.
- *
- * @param root - Project directory
- * @param config - Parsed JSON config
- * @returns Normalized ShadertoyProject
- */
-async function loadProjectWithConfig(root, config) {
-    // Extract pass configs from top level
+// =============================================================================
+// Shadertoy Mode (iChannel-based)
+// =============================================================================
+async function loadShadertoyProject(root, config) {
     const passConfigs = {
         Image: config.Image,
         BufferA: config.BufferA,
@@ -201,86 +233,224 @@ async function loadProjectWithConfig(root, config) {
         BufferC: config.BufferC,
         BufferD: config.BufferD,
     };
-    // Validate: must have Image pass (or be empty config for simple shader)
     const hasAnyPass = passConfigs.Image || passConfigs.BufferA || passConfigs.BufferB ||
         passConfigs.BufferC || passConfigs.BufferD;
     if (!hasAnyPass) {
-        // Empty config = simple Image pass with no channels
         passConfigs.Image = {};
     }
-    // Resolve commonSource
-    let commonSource = null;
-    if (config.common) {
-        const commonPath = path.join(root, config.common);
-        if (!(await fileExists(commonPath))) {
-            throw new Error(`Common GLSL file '${config.common}' not found in '${root}'.`);
-        }
-        commonSource = await fs.readFile(commonPath, 'utf8');
-    }
-    else {
-        // Check for default common.glsl
-        const defaultCommonPath = path.join(root, 'common.glsl');
-        if (await fileExists(defaultCommonPath)) {
-            commonSource = await fs.readFile(defaultCommonPath, 'utf8');
-        }
-    }
-    // Texture deduplication map
+    const commonSource = await resolveCommonSource(root, config.common);
+    // Texture deduplication
     const textureMap = new Map();
-    /**
-     * Register a texture and return its internal name.
-     */
     function registerTexture(j) {
         const filter = j.filter ?? 'linear';
         const wrap = j.wrap ?? 'repeat';
         const key = `${j.texture}|${filter}|${wrap}`;
-        let existing = textureMap.get(key);
-        if (existing) {
+        const existing = textureMap.get(key);
+        if (existing)
             return existing.name;
-        }
         const name = `tex${textureMap.size}`;
-        const tex = {
-            name,
-            source: j.texture,
-            filter,
-            wrap,
-        };
-        textureMap.set(key, tex);
+        textureMap.set(key, { name, source: j.texture, filter, wrap });
         return name;
     }
-    /**
-     * Parse a channel object into ChannelSource.
-     */
     function parseChannelObject(value, passName, channelKey) {
-        // Buffer channel
         if ('buffer' in value) {
             const buf = value.buffer;
             if (!isPassName(buf)) {
                 throw new Error(`Invalid buffer name '${buf}' for ${channelKey} in pass '${passName}' at '${root}'.`);
             }
-            return {
-                kind: 'buffer',
-                buffer: buf,
-                current: !!value.current,
-            };
+            return { kind: 'buffer', buffer: buf, current: !!value.current };
         }
-        // Texture channel
         if ('texture' in value) {
-            const internalName = registerTexture(value);
-            return {
-                kind: 'texture',
-                name: internalName,
-                cubemap: value.type === 'cubemap',
-            };
+            return { kind: 'texture', name: registerTexture(value), cubemap: value.type === 'cubemap' };
         }
-        // Keyboard channel
-        if ('keyboard' in value) {
+        if ('keyboard' in value)
             return { kind: 'keyboard' };
+        if ('audio' in value)
+            return { kind: 'audio' };
+        if ('webcam' in value)
+            return { kind: 'webcam' };
+        if ('video' in value)
+            return { kind: 'video', src: value.video };
+        if ('script' in value)
+            return { kind: 'script', name: value.script };
+        throw new Error(`Invalid channel object for ${channelKey} in pass '${passName}' at '${root}'.`);
+    }
+    async function loadPass(name, passConfig) {
+        if (!passConfig)
+            return undefined;
+        const sourceRel = passConfig.source ?? defaultSourceForPass(name);
+        const sourcePath = path.join(root, sourceRel);
+        if (!(await fileExists(sourcePath))) {
+            throw new Error(`Source GLSL file for pass '${name}' not found at '${sourceRel}' in '${root}'.`);
+        }
+        const glslSource = await fs.readFile(sourcePath, 'utf8');
+        const channelSources = [];
+        for (const key of CHANNEL_KEYS) {
+            const rawValue = passConfig[key];
+            if (!rawValue) {
+                channelSources.push({ kind: 'none' });
+                continue;
+            }
+            const parsed = parseChannelValue(rawValue);
+            if (!parsed) {
+                channelSources.push({ kind: 'none' });
+                continue;
+            }
+            channelSources.push(parseChannelObject(parsed, name, key));
+        }
+        return { name, glslSource, channels: channelSources };
+    }
+    const imagePass = await loadPass('Image', passConfigs.Image);
+    const bufferAPass = await loadPass('BufferA', passConfigs.BufferA);
+    const bufferBPass = await loadPass('BufferB', passConfigs.BufferB);
+    const bufferCPass = await loadPass('BufferC', passConfigs.BufferC);
+    const bufferDPass = await loadPass('BufferD', passConfigs.BufferD);
+    if (!imagePass && (bufferAPass || bufferBPass || bufferCPass || bufferDPass)) {
+        throw new Error(`config.json at '${root}' has buffers but no Image pass.`);
+    }
+    if (!imagePass) {
+        throw new Error(`config.json at '${root}' must define an Image pass.`);
+    }
+    const title = config.title ?? path.basename(root);
+    return {
+        mode: 'shadertoy',
+        root,
+        meta: { title, author: config.author ?? null, description: config.description ?? null },
+        layout: config.layout ?? DEFAULT_LAYOUT,
+        theme: config.theme ?? DEFAULT_THEME,
+        controls: config.controls ?? DEFAULT_CONTROLS,
+        startPaused: config.startPaused ?? false,
+        pixelRatio: config.pixelRatio ?? null,
+        commonSource,
+        passes: {
+            Image: imagePass,
+            BufferA: bufferAPass,
+            BufferB: bufferBPass,
+            BufferC: bufferCPass,
+            BufferD: bufferDPass,
+        },
+        textures: Array.from(textureMap.values()),
+        uniforms: {},
+        script: null,
+    };
+}
+// =============================================================================
+// Standard Mode
+// =============================================================================
+/**
+ * Normalize buffers config: array shorthand to object form.
+ */
+function normalizeBuffersConfig(buffers) {
+    if (!buffers)
+        return {};
+    if (Array.isArray(buffers)) {
+        const result = {};
+        for (const name of buffers) {
+            result[name] = {};
         }
+        return result;
+    }
+    return buffers;
+}
+/**
+ * Load a standard mode project.
+ * Supports both named buffers and pass-level configs (Image/BufferA/etc.).
+ */
+async function loadStandardProject(root, config) {
+    // Validate uniforms early
+    if (config.uniforms) {
+        validateUniforms(config.uniforms, root);
+    }
+    const commonSource = await resolveCommonSource(root, config.common);
+    // Check if using named buffers or pass-level configs
+    const hasNamedBuffers = config.buffers && Object.keys(normalizeBuffersConfig(config.buffers)).length > 0;
+    const hasPassConfigs = config.Image || config.BufferA || config.BufferB ||
+        config.BufferC || config.BufferD;
+    if (hasNamedBuffers && hasPassConfigs) {
+        throw new Error(`Standard mode at '${root}' cannot use both named 'buffers' and pass-level configs (Image/BufferA/etc.). Choose one approach.`);
+    }
+    if (hasNamedBuffers) {
+        return loadStandardWithNamedBuffers(root, config, commonSource);
+    }
+    if (hasPassConfigs) {
+        return loadStandardWithPassConfigs(root, config, commonSource);
+    }
+    // Simple single-pass standard project (config with settings only)
+    const imagePath = path.join(root, 'image.glsl');
+    if (!(await fileExists(imagePath))) {
+        throw new Error(`Standard mode project at '${root}' requires 'image.glsl'.`);
+    }
+    const imageSource = await fs.readFile(imagePath, 'utf8');
+    const title = config.title ?? path.basename(root);
+    return {
+        mode: 'standard',
+        root,
+        meta: { title, author: config.author ?? null, description: config.description ?? null },
+        layout: config.layout ?? DEFAULT_LAYOUT,
+        theme: config.theme ?? DEFAULT_THEME,
+        controls: config.controls ?? DEFAULT_CONTROLS,
+        startPaused: config.startPaused ?? false,
+        pixelRatio: config.pixelRatio ?? null,
+        commonSource,
+        passes: {
+            Image: {
+                name: 'Image',
+                glslSource: imageSource,
+                channels: [{ kind: 'none' }, { kind: 'none' }, { kind: 'none' }, { kind: 'none' }],
+            },
+        },
+        textures: [],
+        uniforms: config.uniforms ?? {},
+        script: null,
+    };
+}
+/**
+ * Standard mode with pass-level configs (Image, BufferA, etc.) + uniforms.
+ * Reuses the same iChannel mechanism as shadertoy mode but sets mode to 'standard'.
+ */
+async function loadStandardWithPassConfigs(root, config, commonSource) {
+    const passConfigs = {
+        Image: config.Image,
+        BufferA: config.BufferA,
+        BufferB: config.BufferB,
+        BufferC: config.BufferC,
+        BufferD: config.BufferD,
+    };
+    // Texture deduplication
+    const textureMap = new Map();
+    function registerTexture(j) {
+        const filter = j.filter ?? 'linear';
+        const wrap = j.wrap ?? 'repeat';
+        const key = `${j.texture}|${filter}|${wrap}`;
+        const existing = textureMap.get(key);
+        if (existing)
+            return existing.name;
+        const name = `tex${textureMap.size}`;
+        textureMap.set(key, { name, source: j.texture, filter, wrap });
+        return name;
+    }
+    function parseChannelObject(value, passName, channelKey) {
+        if ('buffer' in value) {
+            if (!isPassName(value.buffer)) {
+                throw new Error(`Invalid buffer name '${value.buffer}' for ${channelKey} in pass '${passName}' at '${root}'.`);
+            }
+            return { kind: 'buffer', buffer: value.buffer, current: !!value.current };
+        }
+        if ('texture' in value) {
+            return { kind: 'texture', name: registerTexture(value), cubemap: value.type === 'cubemap' };
+        }
+        if ('keyboard' in value)
+            return { kind: 'keyboard' };
+        if ('audio' in value)
+            return { kind: 'audio' };
+        if ('webcam' in value)
+            return { kind: 'webcam' };
+        if ('video' in value)
+            return { kind: 'video', src: value.video };
+        if ('script' in value)
+            return { kind: 'script', name: value.script };
         throw new Error(`Invalid channel object for ${channelKey} in pass '${passName}' at '${root}'.`);
     }
-    /**
-     * Load a single pass from simplified config.
-     */
     async function loadPass(name, passConfig) {
         if (!passConfig)
             return undefined;
@@ -290,16 +460,13 @@ async function loadProjectWithConfig(root, config) {
             throw new Error(`Source GLSL file for pass '${name}' not found at '${sourceRel}' in '${root}'.`);
         }
         const glslSource = await fs.readFile(sourcePath, 'utf8');
-        // Normalize channels (always 4 channels)
         const channelSources = [];
-        const channelKeys = ['iChannel0', 'iChannel1', 'iChannel2', 'iChannel3'];
-        for (const key of channelKeys) {
+        for (const key of CHANNEL_KEYS) {
             const rawValue = passConfig[key];
             if (!rawValue) {
                 channelSources.push({ kind: 'none' });
                 continue;
             }
-            // Parse string shorthand or use object directly
             const parsed = parseChannelValue(rawValue);
             if (!parsed) {
                 channelSources.push({ kind: 'none' });
@@ -307,35 +474,29 @@ async function loadProjectWithConfig(root, config) {
             }
             channelSources.push(parseChannelObject(parsed, name, key));
         }
-        return {
-            name,
-            glslSource,
-            channels: channelSources,
-        };
+        return { name, glslSource, channels: channelSources };
     }
-    // Load all passes
     const imagePass = await loadPass('Image', passConfigs.Image);
     const bufferAPass = await loadPass('BufferA', passConfigs.BufferA);
     const bufferBPass = await loadPass('BufferB', passConfigs.BufferB);
     const bufferCPass = await loadPass('BufferC', passConfigs.BufferC);
     const bufferDPass = await loadPass('BufferD', passConfigs.BufferD);
-    // If no Image pass was loaded but we have buffers, that's an error
     if (!imagePass && (bufferAPass || bufferBPass || bufferCPass || bufferDPass)) {
         throw new Error(`config.json at '${root}' has buffers but no Image pass.`);
     }
-    // If still no Image pass, create empty one
     if (!imagePass) {
         throw new Error(`config.json at '${root}' must define an Image pass.`);
     }
-    // Build metadata
     const title = config.title ?? path.basename(root);
-    const author = config.author ?? null;
-    const description = config.description ?? null;
-    const project = {
+    return {
+        mode: 'standard',
         root,
-        meta: { title, author, description },
-        layout: config.layout ?? 'default',
-        controls: config.controls ?? false,
+        meta: { title, author: config.author ?? null, description: config.description ?? null },
+        layout: config.layout ?? DEFAULT_LAYOUT,
+        theme: config.theme ?? DEFAULT_THEME,
+        controls: config.controls ?? DEFAULT_CONTROLS,
+        startPaused: config.startPaused ?? false,
+        pixelRatio: config.pixelRatio ?? null,
         commonSource,
         passes: {
             Image: imagePass,
@@ -345,6 +506,97 @@ async function loadProjectWithConfig(root, config) {
             BufferD: bufferDPass,
         },
         textures: Array.from(textureMap.values()),
+        uniforms: config.uniforms ?? {},
+        script: null,
+    };
+}
+/**
+ * Standard mode with named buffers and textures.
+ */
+async function loadStandardWithNamedBuffers(root, config, commonSource) {
+    const buffersConfig = normalizeBuffersConfig(config.buffers);
+    const bufferNames = Object.keys(buffersConfig);
+    if (bufferNames.length > 4) {
+        throw new Error(`Standard mode at '${root}' supports max 4 buffers, got ${bufferNames.length}: ${bufferNames.join(', ')}`);
+    }
+    const bufferNameToPass = new Map();
+    for (let i = 0; i < bufferNames.length; i++) {
+        bufferNameToPass.set(bufferNames[i], BUFFER_PASS_NAMES[i]);
+    }
+    // Texture deduplication
+    const textureMap = new Map();
+    function registerTexture(source, filter = 'linear', wrap = 'repeat') {
+        const key = `${source}|${filter}|${wrap}`;
+        const existing = textureMap.get(key);
+        if (existing)
+            return existing.name;
+        const name = `tex${textureMap.size}`;
+        textureMap.set(key, { name, source, filter, wrap });
+        return name;
+    }
+    // Build namedSamplers
+    const namedSamplers = new Map();
+    for (const [bufName, passName] of bufferNameToPass) {
+        namedSamplers.set(bufName, { kind: 'buffer', buffer: passName, current: false });
+    }
+    for (const [texName, texValue] of Object.entries(config.textures ?? {})) {
+        if (texValue === 'keyboard') {
+            namedSamplers.set(texName, { kind: 'keyboard' });
+        }
+        else if (texValue === 'audio') {
+            namedSamplers.set(texName, { kind: 'audio' });
+        }
+        else if (texValue === 'webcam') {
+            namedSamplers.set(texName, { kind: 'webcam' });
+        }
+        else {
+            const internalName = registerTexture(texValue);
+            namedSamplers.set(texName, { kind: 'texture', name: internalName, cubemap: false });
+        }
+    }
+    const noChannels = [{ kind: 'none' }, { kind: 'none' }, { kind: 'none' }, { kind: 'none' }];
+    // Load Image pass
+    const imagePath = path.join(root, 'image.glsl');
+    if (!(await fileExists(imagePath))) {
+        throw new Error(`Standard mode project at '${root}' requires 'image.glsl'.`);
+    }
+    const imageSource = await fs.readFile(imagePath, 'utf8');
+    const passes = {
+        Image: {
+            name: 'Image',
+            glslSource: imageSource,
+            channels: noChannels,
+            namedSamplers: new Map(namedSamplers),
+        },
+    };
+    // Load buffer passes
+    for (const [bufName, passName] of bufferNameToPass) {
+        const sourcePath = path.join(root, `${bufName}.glsl`);
+        if (!(await fileExists(sourcePath))) {
+            throw new Error(`Buffer '${bufName}' requires '${bufName}.glsl' in '${root}'.`);
+        }
+        const glslSource = await fs.readFile(sourcePath, 'utf8');
+        passes[passName] = {
+            name: passName,
+            glslSource,
+            channels: noChannels,
+            namedSamplers: new Map(namedSamplers),
+        };
+    }
+    const title = config.title ?? path.basename(root);
+    return {
+        mode: 'standard',
+        root,
+        meta: { title, author: config.author ?? null, description: config.description ?? null },
+        layout: config.layout ?? DEFAULT_LAYOUT,
+        theme: config.theme ?? DEFAULT_THEME,
+        controls: config.controls ?? DEFAULT_CONTROLS,
+        startPaused: config.startPaused ?? false,
+        pixelRatio: config.pixelRatio ?? null,
+        commonSource,
+        passes,
+        textures: Array.from(textureMap.values()),
+        uniforms: config.uniforms ?? {},
+        script: null,
     };
-    return project;
 }