pixifact 0.3.0 → 0.5.0

package/dist/compiler/spec.d.ts

@@ -1,7 +1,12 @@
-export type SceneTemplatePrimitiveType = 'Group' | 'Container' | 'Sprite' | 'Text' | 'Graphics' | 'Rect' | 'Image' | 'NineImage' | 'TileImage' | 'BitmapText' | 'HTMLText' | 'Mesh' | 'NineSliceSprite' | 'TilingSprite' | 'DOMContainer' | 'GridContainer' | 'HBoxContainer' | 'ScrollContainer' | 'VBoxContainer';
+export type SceneTemplatePrimitiveType = 'Group' | 'Container' | 'Sprite' | 'Text' | 'Label' | 'BitmapLabel' | 'Graphics' | 'Rect' | 'Image' | 'NineImage' | 'TileImage' | 'BitmapText' | 'HTMLText' | 'Mesh' | 'NineSliceSprite' | 'TilingSprite' | 'DOMContainer' | 'GridContainer' | 'HBoxContainer' | 'ScrollContainer' | 'VBoxContainer';
 export type SceneTemplateScalarValue = string | number | boolean;
 export type SceneTemplateStructValue = Record<string, SceneTemplateScalarValue>;
-export type SceneTemplateValue = SceneTemplateScalarValue | SceneTemplateStructValue;
+export interface SceneTemplateBindingValue {
+    kind: 'binding';
+    path: [string] | [string, string];
+}
+export type SceneTemplateValue = SceneTemplateScalarValue | SceneTemplateStructValue | SceneTemplateBindingValue;
+export declare function isSceneTemplateBindingValue(value: SceneTemplateValue | undefined): value is SceneTemplateBindingValue;
 export type SceneTemplatePrimitivePropType = 'string' | 'number' | 'boolean';
 export interface SceneTemplatePrimitivePropContract {
     type: SceneTemplatePrimitivePropType;
@@ -17,7 +22,14 @@ export interface SceneTemplateStructPropContract {
     sourceScene?: string;
     fields: Record<string, SceneTemplateStructFieldContract>;
 }
-export type SceneTemplatePropContract = SceneTemplatePrimitivePropContract | SceneTemplateStructPropContract;
+export type SceneTemplateVariantFields = Record<string, SceneTemplateScalarValue>;
+export type SceneTemplateVariants = Record<string, SceneTemplateVariantFields>;
+export interface SceneTemplateVariantPropContract {
+    type: 'variant';
+    default: string;
+    variants: SceneTemplateVariants;
+}
+export type SceneTemplatePropContract = SceneTemplatePrimitivePropContract | SceneTemplateStructPropContract | SceneTemplateVariantPropContract;
 export interface SceneTemplateEventContract {
     type: 'action';
 }
@@ -73,8 +85,8 @@ export interface CompileSceneTemplateOptions {
     scriptImport?: SceneTemplateScriptImport;
     sceneImports?: SceneTemplateScriptImport[];
     sceneClassAliases?: Record<string, string>;
+    sceneDependencies?: string[];
     sceneInterfaces?: Record<string, SceneTemplateInterface>;
-    textureImports?: Record<string, string>;
 }
 export interface SceneScriptInterface {
     scene: string;
@@ -84,11 +96,10 @@ export interface SceneScriptInterface {
 }
 export type SceneClassDecorator = ClassDecorator;
 export type SceneMemberDecorator = PropertyDecorator & MethodDecorator;
-export type SceneStructConstructor = new () => object;
-export type ScenePropType = StringConstructor | NumberConstructor | BooleanConstructor | SceneStructConstructor;
+export type SceneVariants = Record<string, Record<string, SceneTemplateScalarValue>>;
 export interface ScenePropDecoratorOptions {
-    type: ScenePropType;
-    default?: SceneTemplateValue;
+    default?: SceneTemplateScalarValue;
+    variants?: SceneVariants;
 }
 export interface SceneEventDecoratorOptions {
     name?: string;

package/dist/compiler/spec.js

@@ -1 +1,3 @@
-export {};
+export function isSceneTemplateBindingValue(value) {
+    return !!value && typeof value === 'object' && value.kind === 'binding';
+}

package/dist/compiler/templateParser.js

@@ -5,6 +5,8 @@ const pixiTypes = new Set([
     'Container',
     'Sprite',
     'Text',
+    'Label',
+    'BitmapLabel',
     'Graphics',
     'Rect',
     'Image',
@@ -148,6 +150,10 @@ function isEventAttribute(name) {
     return eventName(name) !== undefined;
 }
 function parseAttributeValue(name, value) {
+    const binding = parseBindingValue(value);
+    if (binding) {
+        return binding;
+    }
     if (pixiSceneFieldSchema(name)?.type === 'string') {
         return value;
     }
@@ -161,6 +167,19 @@ function parseAttributeValue(name, value) {
         return Number.parseInt(value.slice(1), 16);
     return value;
 }
+function parseBindingValue(value) {
+    const match = /^\{([A-Za-z_$][\w$]*)(?:\.([A-Za-z_$][\w$]*))?\}$/.exec(value);
+    if (!match) {
+        if (value.startsWith('{') || value.endsWith('}')) {
+            throw new Error(`Unsupported Scene binding "${value}". Use {prop} or {variant.field}.`);
+        }
+        return undefined;
+    }
+    return {
+        kind: 'binding',
+        path: match[2] ? [match[1], match[2]] : [match[1]],
+    };
+}
 function removeAttribute(element, name) {
     const attributes = { ...element.attributes };
     delete attributes[name];

package/dist/compiler/templateSerializer.js

@@ -79,18 +79,24 @@ function serializeAttributes(attributes) {
 }
 function flattenAttributes(attributes) {
     return attributes.flatMap(([name, value]) => {
-        if (!value || typeof value !== 'object') {
+        if (!value || typeof value !== 'object' || isBindingValue(value)) {
             return [[name, value]];
         }
         return Object.entries(value).map(([field, fieldValue]) => [`${name}.${field}`, fieldValue]);
     });
 }
 function formatAttributeValue(name, value) {
+    if (isBindingValue(value)) {
+        return `{${value.path.join('.')}}`;
+    }
     if (typeof value === 'number' && colorPropNames.has(name)) {
         return `#${value.toString(16).padStart(6, '0').slice(-6)}`;
     }
     return String(value);
 }
+function isBindingValue(value) {
+    return typeof value === 'object' && value.kind === 'binding';
+}
 function escapeAttribute(value) {
     return value
         .replaceAll('&', '&')

package/dist/compiler/typescriptCompiler.js

@@ -1,13 +1,18 @@
-import { pixiSceneDisplayProps, pixiSceneGraphicsProps, pixiSceneLayoutProps, pixiSceneRectProps, pixiSceneSpriteLikeProps, pixiSceneTextStyleProps, pixiSceneTransformProps, } from './pixiNodeSchema.js';
+import { pixiSceneDisplayProps, pixiSceneGraphicsProps, pixiSceneLabelProps, pixiSceneLayoutProps, pixiSceneRectProps, pixiSceneSpriteLikeProps, pixiSceneTextStyleProps, pixiSceneTransformProps, } from './pixiNodeSchema.js';
+import { compilerSceneNodeLocator } from './commands/index.js';
 const transformProps = new Set(pixiSceneTransformProps);
 const layoutProps = new Set(pixiSceneLayoutProps);
 const pixiProps = new Set(pixiSceneDisplayProps);
 const spriteProps = new Set(pixiSceneSpriteLikeProps);
 const graphicsProps = new Set(pixiSceneGraphicsProps);
+const labelProps = new Set(pixiSceneLabelProps);
 const rectProps = new Set(pixiSceneRectProps);
 const textStyleProps = new Set(pixiSceneTextStyleProps);
-const runtimeNodeTypes = new Set(['Group', 'GridContainer', 'HBoxContainer', 'ScrollContainer', 'VBoxContainer', 'Rect', 'Image', 'NineImage', 'TileImage']);
+const runtimeNodeTypes = new Set(['Group', 'GridContainer', 'HBoxContainer', 'ScrollContainer', 'VBoxContainer', 'Label', 'BitmapLabel', 'Rect', 'Image', 'NineImage', 'TileImage']);
 const runtimeNodeProps = new Set(['columns', 'gap', 'gapX', 'gapY', 'alignX', 'alignY', 'justify', 'direction', 'scrollX', 'scrollY']);
+function isSceneBindingValue(value) {
+    return !!value && typeof value === 'object' && value.kind === 'binding';
+}
 export function compileSceneTemplateToTs(template, options = {}) {
     const context = new CompileContext(template, options);
     return context.compile();
@@ -37,16 +42,18 @@ class CompileContext {
         const functionName = this.options.functionName || `mount${this.template.name}Scene`;
         const actionsParameter = this.options.actionsParameter || 'actions';
         const partsType = this.#formatPartsType();
-        const textureLoads = this.#formatTextureLoads();
+        const texturePreparation = this.#formatTexturePreparation();
         this.#lines.push(`export function ${functionName}(root: Group${this.#hasEvents() ? `, ${actionsParameter}: Record<string, () => void> = {}` : ''}) {`);
+        this.#lines.push('  const __pixifactNodes: Record<string, Container> = {};');
         this.#lines.push('  const __pixifactSlots: Record<string, Container> = {};');
         this.#applyRootProps();
-        for (const child of this.template.children) {
-            this.#compileNode(child, 'root', actionsParameter);
+        for (const [index, child] of this.template.children.entries()) {
+            this.#compileNode(child, 'root', actionsParameter, String(index));
         }
         this.#lines.push('  return {');
         this.#lines.push('    root,');
         this.#lines.push(`    parts: { ${this.#parts.map((part) => part.id).join(', ')} },`);
+        this.#lines.push('    nodes: __pixifactNodes,');
         this.#lines.push('    slots: __pixifactSlots,');
         this.#lines.push('  };');
         this.#lines.push('}');
@@ -57,7 +64,10 @@ class CompileContext {
             }
             this.#lines.push('');
             this.#lines.push(`registerScene(${JSON.stringify(this.options.registrationPath)}, {`);
+            this.#lines.push(`  assets: ${JSON.stringify([...this.#textures.keys()])},`);
+            this.#lines.push(`  dependencies: ${JSON.stringify(this.options.sceneDependencies ?? [])},`);
             this.#lines.push(`  mount: ${functionName},`);
+            this.#lines.push(`  prepare: ${this.#prepareFunctionName()},`);
             this.#lines.push('});');
             if (this.options.scriptImport) {
                 this.#lines.push(`registerSceneClass(${this.options.scriptImport.localName}, ${JSON.stringify(this.options.registrationPath)});`);
@@ -66,7 +76,7 @@ class CompileContext {
         const imports = this.#formatImports();
         return [
             imports,
-            textureLoads,
+            texturePreparation,
             partsType,
             this.#lines.join('\n'),
         ].filter(Boolean).join('\n\n') + '\n';
@@ -79,9 +89,6 @@ class CompileContext {
             ])];
         const runtimeImports = [...new Set(['Group', ...[...this.#pixiRuntimeImports].sort()])];
         const lines = [`import { ${imports.join(', ')} } from 'pixi.js';`, `import { ${runtimeImports.join(', ')} } from 'pixifact/runtime';`];
-        for (const [texture, variable] of this.#textureImportEntries()) {
-            lines.push(`import ${variable} from ${JSON.stringify(this.options.textureImports?.[texture])};`);
-        }
         for (const sceneImport of this.options.sceneImports ?? []) {
             const classImport = sceneImport.exportName === sceneImport.localName
                 ? sceneImport.exportName
@@ -98,7 +105,7 @@ class CompileContext {
             lines.push(`import { ${this.options.scriptImport.exportName} as ${this.options.scriptImport.localName} } from ${JSON.stringify(this.options.scriptImport.source)};`);
         }
         if (this.#runtimeImports.size > 0) {
-            lines.push(`import { ${[...this.#runtimeImports].sort().join(', ')} } from 'pixifact/compiler';`);
+            lines.push(`import { ${[...this.#runtimeImports].sort().join(', ')} } from 'pixifact/scene';`);
         }
         return lines.join('\n');
     }
@@ -109,6 +116,7 @@ class CompileContext {
             lines.push(`    ${part.id}: ${part.type};`);
         }
         lines.push('  };');
+        lines.push('  nodes: Record<string, Container>;');
         lines.push('  slots: Record<string, Container>;');
         lines.push('};');
         return lines.join('\n');
@@ -174,16 +182,27 @@ class CompileContext {
             }
         }
     }
-    #formatTextureLoads() {
+    #formatTexturePreparation() {
         if (this.#textures.size === 0) {
-            return '';
+            return `export async function ${this.#prepareFunctionName()}() {}`;
         }
-        this.#pixiImports.add('Assets');
-        return [...this.#textures.entries()]
-            .map(([texture, variable]) => `const ${variable} = await Assets.load(${this.#textureLoadSource(texture)});`)
-            .join('\n');
-    }
-    #compileNode(node, parent, actionsParameter) {
+        this.#pixiImports.add('Texture');
+        this.#runtimeImports.add('loadSceneTexture');
+        const entries = [...this.#textures.entries()];
+        return [
+            ...entries.map(([, variable]) => `let ${variable}: Texture;`),
+            '',
+            `export async function ${this.#prepareFunctionName()}() {`,
+            `  [${entries.map(([, variable]) => variable).join(', ')}] = await Promise.all([`,
+            ...entries.map(([texture]) => `    loadSceneTexture(${JSON.stringify(texture)}),`),
+            '  ]);',
+            '}',
+        ].join('\n');
+    }
+    #prepareFunctionName() {
+        return `prepare${this.template.name}Scene`;
+    }
+    #compileNode(node, parent, actionsParameter, path) {
         if (node.kind === 'slotOutlet') {
             this.#runtimeImports.add('registerSlot');
             this.#lines.push(`  __pixifactSlots[${JSON.stringify(node.name)}] = ${parent};`);
@@ -191,26 +210,30 @@ class CompileContext {
             return;
         }
         if (node.kind === 'sceneInstance') {
-            this.#compileSceneInstance(node, parent, actionsParameter);
+            this.#compileSceneInstance(node, parent, actionsParameter, path);
             return;
         }
-        this.#compilePixiNode(node, parent, actionsParameter);
+        this.#compilePixiNode(node, parent, actionsParameter, path);
     }
-    #compilePixiNode(node, parent, actionsParameter) {
+    #compilePixiNode(node, parent, actionsParameter, path) {
         const variable = node.id || this.#anonymousName(node.type);
+        const locator = compilerSceneNodeLocator(node, path);
         this.#lines.push(`  const ${variable} = ${this.#constructPixiNode(node)};`);
         this.#applyNodeId(variable, node.id);
         this.#applyPixiProps(variable, node.props, false, undefined, node.type);
         this.#applyParentSorting(parent, node.props);
         this.#lines.push(`  ${parent}.addChild(${variable});`);
-        for (const child of node.children) {
-            this.#compileNode(child, variable, actionsParameter);
+        this.#lines.push(`  __pixifactNodes[${JSON.stringify(locator)}] = ${variable};`);
+        for (const [index, child] of node.children.entries()) {
+            this.#compileNode(child, variable, actionsParameter, `${locator}/${index}`);
         }
     }
-    #compileSceneInstance(node, parent, actionsParameter) {
+    #compileSceneInstance(node, parent, actionsParameter, path) {
         const variable = node.id || this.#anonymousName(node.type);
+        const locator = compilerSceneNodeLocator(node, path);
         const constructorName = this.#sceneConstructorName(node);
-        this.#lines.push(`  const ${variable} = new ${constructorName}();`);
+        const constructorArgs = this.#sceneInstanceConstructorArgs(variable, node);
+        this.#lines.push(`  const ${variable} = new ${constructorName}(${constructorArgs});`);
         this.#applyPixiProps(variable, node.props, true, node);
         for (const [name, action] of Object.entries(node.events)) {
             this.#runtimeImports.add('connectSceneEvent');
@@ -218,30 +241,34 @@ class CompileContext {
         }
         this.#applyParentSorting(parent, node.props);
         this.#lines.push(`  ${parent}.addChild(${variable});`);
+        this.#lines.push(`  __pixifactNodes[${JSON.stringify(locator)}] = ${variable};`);
         for (const [slot, children] of Object.entries(node.slots)) {
-            for (const child of children) {
-                const childVariable = this.#compileSlottedNode(child, variable, actionsParameter);
+            for (const [index, child] of children.entries()) {
+                const childVariable = this.#compileSlottedNode(child, variable, actionsParameter, `${locator}/slot:${slot}/${index}`);
                 this.#runtimeImports.add('mount');
                 this.#lines.push(`  mount(${variable}, ${childVariable}, ${JSON.stringify(slot)});`);
             }
         }
     }
-    #compileSlottedNode(node, slotTarget, actionsParameter) {
+    #compileSlottedNode(node, slotTarget, actionsParameter, path) {
         if (node.kind === 'slotOutlet') {
             throw new Error(`Cannot place <slot> inside ${slotTarget}.`);
         }
         if (node.kind === 'sceneInstance') {
             const variable = node.id || this.#anonymousName(node.type);
+            const locator = compilerSceneNodeLocator(node, path);
             const constructorName = this.#sceneConstructorName(node);
-            this.#lines.push(`  const ${variable} = new ${constructorName}();`);
+            const constructorArgs = this.#sceneInstanceConstructorArgs(variable, node);
+            this.#lines.push(`  const ${variable} = new ${constructorName}(${constructorArgs});`);
             this.#applyPixiProps(variable, node.props, true, node);
             for (const [name, action] of Object.entries(node.events)) {
                 this.#runtimeImports.add('connectSceneEvent');
                 this.#lines.push(`  connectSceneEvent(${variable}.${name}, ${JSON.stringify(action)}, root, ${actionsParameter});`);
             }
+            this.#lines.push(`  __pixifactNodes[${JSON.stringify(locator)}] = ${variable};`);
             for (const [slot, children] of Object.entries(node.slots)) {
-                for (const child of children) {
-                    const childVariable = this.#compileSlottedNode(child, variable, actionsParameter);
+                for (const [index, child] of children.entries()) {
+                    const childVariable = this.#compileSlottedNode(child, variable, actionsParameter, `${locator}/slot:${slot}/${index}`);
                     this.#runtimeImports.add('mount');
                     this.#lines.push(`  mount(${variable}, ${childVariable}, ${JSON.stringify(slot)});`);
                 }
@@ -249,17 +276,19 @@ class CompileContext {
             return variable;
         }
         const variable = node.id || this.#anonymousName(node.type);
+        const locator = compilerSceneNodeLocator(node, path);
         this.#lines.push(`  const ${variable} = ${this.#constructPixiNode(node)};`);
         this.#applyNodeId(variable, node.id);
         this.#applyPixiProps(variable, node.props, false, undefined, node.type);
-        for (const child of node.children) {
-            this.#compileNode(child, variable, actionsParameter);
+        this.#lines.push(`  __pixifactNodes[${JSON.stringify(locator)}] = ${variable};`);
+        for (const [index, child] of node.children.entries()) {
+            this.#compileNode(child, variable, actionsParameter, `${locator}/${index}`);
         }
         return variable;
     }
     #constructPixiNode(node) {
         if (node.type === 'Text' || node.type === 'BitmapText' || node.type === 'HTMLText') {
-            const text = this.#stringValue(node.props.text ?? '');
+            const text = this.#stringValue(isSceneBindingValue(node.props.text) ? '' : node.props.text ?? '');
             const style = this.#styleObject(node.props);
             return `new ${node.type}({ text: ${text}${style ? `, style: ${style}` : ''} })`;
         }
@@ -285,6 +314,31 @@ class CompileContext {
     #sceneConstructorName(node) {
         return this.options.sceneClassAliases?.[node.scene] ?? node.type;
     }
+    #sceneInstanceConstructorArgs(variable, node) {
+        const sceneInterface = this.options.sceneInterfaces?.[node.scene];
+        if (!sceneInterface) {
+            return '';
+        }
+        const entries = [];
+        for (const [key, value] of Object.entries(node.props)) {
+            const contract = sceneInterface.props[key];
+            if (!contract) {
+                continue;
+            }
+            if (isSceneBindingValue(value)) {
+                this.#runtimeImports.add('readSceneBindingValue');
+                entries.push(`${key}: readSceneBindingValue(root, ${JSON.stringify(value)})`);
+                continue;
+            }
+            if (contract.type === 'struct' && value && typeof value === 'object') {
+                const structVariable = this.#createStructValue(variable, key, value, contract);
+                entries.push(`${key}: ${structVariable}`);
+                continue;
+            }
+            entries.push(`${key}: ${this.#value(value)}`);
+        }
+        return entries.length > 0 ? `{ ${entries.join(', ')} }` : '';
+    }
     #sceneStructImports(sceneImport) {
         const scene = this.#sceneImportScene(sceneImport);
         if (!scene) {
@@ -355,6 +409,18 @@ class CompileContext {
         return contract.sourceScene ?? instanceScene;
     }
     #applyPixiProps(variable, props, instance = false, sceneInstance, pixiType) {
+        const publicProps = new Set(Object.keys(sceneInstance ? this.options.sceneInterfaces?.[sceneInstance.scene]?.props ?? {} : {}));
+        const bindingEntries = Object.entries(props).filter((entry) => (isSceneBindingValue(entry[1]) && !publicProps.has(entry[0])));
+        props = Object.fromEntries(Object.entries(props).filter(([, value]) => !isSceneBindingValue(value)));
+        if (sceneInstance) {
+            props = Object.fromEntries(Object.entries(props).filter(([key]) => !publicProps.has(key)));
+            for (const [key, value] of Object.entries(sceneInstance.props)) {
+                if (publicProps.has(key) && isSceneBindingValue(value)) {
+                    this.#runtimeImports.add('bindSceneNodeProp');
+                    this.#lines.push(`  bindSceneNodeProp(root, ${JSON.stringify(value)}, ${variable}, ${JSON.stringify(key)});`);
+                }
+            }
+        }
         const x = props.x;
         const y = props.y;
         if (x !== undefined || y !== undefined) {
@@ -390,6 +456,10 @@ class CompileContext {
             this.#drawGraphics(variable, props);
         }
         for (const [key, value] of Object.entries(props)) {
+            if (!instance && (pixiType === 'Label' || pixiType === 'BitmapLabel') && labelProps.has(key)) {
+                this.#lines.push(`  ${variable}.${key} = ${this.#value(value)};`);
+                continue;
+            }
             if (!instance && runtimeNodeProps.has(key)) {
                 this.#lines.push(`  ${variable}.${key} = ${this.#value(value)};`);
                 continue;
@@ -413,7 +483,7 @@ class CompileContext {
             if (instance && layoutProps.has(key)) {
                 continue;
             }
-            if (instance && value && typeof value === 'object') {
+            if (instance && value && typeof value === 'object' && !isSceneBindingValue(value)) {
                 this.#applyStructProp(variable, key, value, sceneInstance);
                 continue;
             }
@@ -421,6 +491,10 @@ class CompileContext {
                 this.#lines.push(`  ${variable}.${key} = ${this.#value(value)};`);
             }
         }
+        for (const [key, binding] of bindingEntries) {
+            this.#runtimeImports.add('bindSceneNodeProp');
+            this.#lines.push(`  bindSceneNodeProp(root, ${JSON.stringify(binding)}, ${variable}, ${JSON.stringify(key)});`);
+        }
     }
     #applyRootProps() {
         const props = { ...this.template.props };
@@ -451,12 +525,16 @@ class CompileContext {
             this.#lines.push(`  ${variable}.${key} = ${this.#value(value)};`);
             return;
         }
+        const structVariable = this.#createStructValue(variable, key, value, contract);
+        this.#lines.push(`  ${variable}.${key} = ${structVariable};`);
+    }
+    #createStructValue(variable, key, value, contract) {
         const structVariable = `${variable}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
         this.#lines.push(`  const ${structVariable} = new ${contract.struct}();`);
         for (const [field, fieldValue] of Object.entries(value)) {
             this.#lines.push(`  ${structVariable}.${field} = ${this.#value(fieldValue)};`);
         }
-        this.#lines.push(`  ${variable}.${key} = ${structVariable};`);
+        return structVariable;
     }
     #sceneInstanceStructContract(sceneInstance, key) {
         const contract = sceneInstance ? this.options.sceneInterfaces?.[sceneInstance.scene]?.props[key] : undefined;
@@ -527,7 +605,7 @@ class CompileContext {
         const entries = [];
         for (const key of pixiSceneTextStyleProps) {
             const value = props[key];
-            if (value !== undefined) {
+            if (value !== undefined && !isSceneBindingValue(value)) {
                 entries.push(`${key}: ${key === 'fontWeight' ? JSON.stringify(String(value)) : this.#value(value)}`);
             }
         }
@@ -578,20 +656,6 @@ class CompileContext {
         this.#textures.set(texture, variable);
         return variable;
     }
-    #textureImportEntries() {
-        return [...this.#textures.keys()]
-            .filter((texture) => this.options.textureImports?.[texture])
-            .map((texture, index) => [texture, `__pixifactTextureUrl${index + 1}`]);
-    }
-    #textureImportVariable(texture) {
-        const index = [...this.#textures.keys()]
-            .filter((key) => this.options.textureImports?.[key])
-            .indexOf(texture);
-        return index >= 0 ? `__pixifactTextureUrl${index + 1}` : undefined;
-    }
-    #textureLoadSource(texture) {
-        return this.#textureImportVariable(texture) ?? this.#value(texture);
-    }
     #textureValue(value) {
         return typeof value === 'string' ? this.#textureVariable(value) : this.#value(value);
     }
@@ -599,6 +663,9 @@ class CompileContext {
         if (typeof value === 'string') {
             return JSON.stringify(value);
         }
+        if (isSceneBindingValue(value)) {
+            throw new Error(`Scene binding ${value.path.join('.')} must be compiled as a binding target.`);
+        }
         if (value && typeof value === 'object') {
             return `{ ${Object.entries(value).map(([key, fieldValue]) => `${key}: ${this.#scalarValue(fieldValue)}`).join(', ')} }`;
         }

package/dist/compiler-node/builtinSceneInterfaces.d.ts

@@ -0,0 +1,6 @@
+import type { SceneTemplateInterface } from '../compiler/spec.js';
+import { type BuiltinSceneScriptSources } from '../compiler/builtinScenes.js';
+export declare function builtinSceneInterface(assetId: string, scriptSources: BuiltinSceneScriptSources): SceneTemplateInterface;
+export declare function builtinSceneInterfaces(scriptSources: BuiltinSceneScriptSources): {
+    [k: string]: SceneTemplateInterface;
+};

package/dist/compiler-node/builtinSceneInterfaces.js

@@ -0,0 +1,27 @@
+import { builtinSceneAssetId, builtinSceneAssetIds, builtinSceneNameFromAssetId, builtinSceneNames, } from '../compiler/builtinScenes.js';
+import { extractSceneScriptInterfaces } from './scriptInterfaceExtractor.js';
+export function builtinSceneInterface(assetId, scriptSources) {
+    return builtinSceneInterfaceDescriptors(scriptSources)[assetId].interface;
+}
+export function builtinSceneInterfaces(scriptSources) {
+    const descriptors = builtinSceneInterfaceDescriptors(scriptSources);
+    return Object.fromEntries(builtinSceneAssetIds().map((assetId) => [assetId, descriptors[assetId].interface]));
+}
+function builtinSceneInterfaceDescriptors(scriptSources) {
+    const descriptors = extractSceneScriptInterfaces(builtinSceneNames.map((name) => ({
+        scene: builtinSceneAssetId(name),
+        fileName: `${name}.ts`,
+        source: scriptSources[name],
+    })));
+    for (const assetId of builtinSceneAssetIds()) {
+        const name = builtinSceneNameFromAssetId(assetId);
+        const descriptor = descriptors[assetId];
+        if (!descriptor) {
+            throw new Error(`Built-in Scene "${assetId}" is missing a @scene script.`);
+        }
+        if (descriptor.className !== name) {
+            throw new Error(`Built-in Scene "${assetId}" name must match @scene class "${descriptor.className}".`);
+        }
+    }
+    return descriptors;
+}

package/dist/compiler-node/index.d.ts

@@ -1,3 +1,5 @@
 export * from '../compiler/compileScenes.js';
 export * from './builtinSceneAssets.js';
+export * from './builtinSceneInterfaces.js';
+export * from './scriptInterfaceExtractor.js';
 export * from './vite.js';

package/dist/compiler-node/index.js

@@ -1,3 +1,5 @@
 export * from '../compiler/compileScenes.js';
 export * from './builtinSceneAssets.js';
+export * from './builtinSceneInterfaces.js';
+export * from './scriptInterfaceExtractor.js';
 export * from './vite.js';

package/dist/{compiler → compiler-node}/scriptInterfaceExtractor.d.ts

@@ -1,4 +1,4 @@
-import type { SceneScriptInterface } from './spec.js';
+import type { SceneScriptInterface } from '../compiler/spec.js';
 export interface ExtractSceneScriptInterfaceOptions {
     scene: string;
 }