@aelionsdk/material-sdk 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FoyonaCZY and AelionSDK contributors
+
+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,7 @@
+# @aelionsdk/material-sdk
+
+Type-safe authoring, validation and packaging tools for Aelion materials
+
+Install with `npm install @aelionsdk/material-sdk@next`.
+
+Version 0.1.0-beta.1 is a prerelease and its API may change before the first stable release. This package is part of [AelionSDK](https://github.com/FoyonaCZY/AelionSDK); see the repository README for supported browsers, examples and deployment requirements.

package/dist/bundled-schemas.d.ts

@@ -0,0 +1,5 @@
+import type { JsonObject } from '@aelionsdk/core';
+export declare const materialPackageSchema: JsonObject;
+export declare const materialDefinitionSchema: JsonObject;
+export declare const materialGraphSchema: JsonObject;
+//# sourceMappingURL=bundled-schemas.d.ts.map

package/dist/bundled-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundled-schemas.d.ts","sourceRoot":"","sources":["../src/bundled-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,eAAO,MAAM,qBAAqB,EAE7B,UAAU,CAAC;AAEhB,eAAO,MAAM,wBAAwB,EAEhC,UAAU,CAAC;AAEhB,eAAO,MAAM,mBAAmB,EAE3B,UAAU,CAAC"}

package/dist/bundled-schemas.js

@@ -0,0 +1,3 @@
+export const materialPackageSchema = JSON.parse(String.raw `{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://schemas.aelion.dev/material/package/v1.json","title":"Aelion Material Package Manifest v1","type":"object","additionalProperties":false,"required":["$schema","protocolVersion","package","materials","files"],"properties":{"$schema":{"const":"https://schemas.aelion.dev/material/package/v1.json"},"protocolVersion":{"const":"1.0.0"},"package":{"$ref":"#/$defs/packageMetadata"},"materials":{"type":"array","minItems":1,"maxItems":256,"items":{"$ref":"#/$defs/materialEntry"}},"files":{"type":"array","maxItems":255,"items":{"$ref":"#/$defs/fileEntry"}}},"$defs":{"identifier":{"type":"string","minLength":1,"maxLength":128,"pattern":"^[a-z0-9]+(?:[._-][a-z0-9]+)*$"},"relativePath":{"type":"string","minLength":1,"maxLength":512,"pattern":"^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\)[^\\u0000]+$"},"packageMetadata":{"type":"object","additionalProperties":false,"required":["id","version","displayName","publisher","license","engines","trust"],"properties":{"id":{"$ref":"#/$defs/identifier"},"version":{"type":"string","pattern":"^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$"},"displayName":{"type":"string","minLength":1,"maxLength":128},"publisher":{"type":"object","additionalProperties":false,"required":["id","name"],"properties":{"id":{"$ref":"#/$defs/identifier"},"name":{"type":"string","minLength":1,"maxLength":128}}},"license":{"type":"string","minLength":1,"maxLength":128},"engines":{"type":"object","additionalProperties":false,"required":["aelion","nodeSet"],"properties":{"aelion":{"type":"string","minLength":1,"maxLength":128},"nodeSet":{"type":"string","minLength":1,"maxLength":128}}},"trust":{"enum":["declarative","trusted-code"]}}},"materialEntry":{"type":"object","additionalProperties":false,"required":["id","kind","definition"],"properties":{"id":{"$ref":"#/$defs/identifier"},"kind":{"enum":["visual-filter","visual-effect","visual-transition","visual-generator"]},"definition":{"$ref":"#/$defs/relativePath"}}},"fileEntry":{"type":"object","additionalProperties":false,"required":["path","mediaType","bytes","sha256"],"properties":{"path":{"$ref":"#/$defs/relativePath"},"mediaType":{"type":"string","minLength":1,"maxLength":128},"bytes":{"type":"integer","minimum":0,"maximum":67108864},"sha256":{"type":"string","pattern":"^[0-9a-f]{64}$"}}}}}`);
+export const materialDefinitionSchema = JSON.parse(String.raw `{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://schemas.aelion.dev/material/definition/v1.json","title":"Aelion Material Definition v1","type":"object","additionalProperties":false,"required":["$schema","protocolVersion","id","kind","display","scopes","ports","parameters","bundledResources","resourceSlots","execution","implementations","splitPolicy"],"properties":{"$schema":{"const":"https://schemas.aelion.dev/material/definition/v1.json"},"protocolVersion":{"const":"1.0.0"},"id":{"$ref":"#/$defs/identifier"},"kind":{"enum":["visual-filter","visual-effect","visual-transition","visual-generator"]},"display":{"$ref":"#/$defs/display"},"scopes":{"type":"array","minItems":1,"uniqueItems":true,"items":{"enum":["source","item","track","sequence","transition"]}},"ports":{"type":"array","minItems":1,"maxItems":16,"items":{"$ref":"#/$defs/port"}},"parameters":{"type":"array","maxItems":64,"items":{"$ref":"#/$defs/parameter"}},"bundledResources":{"type":"array","maxItems":32,"items":{"$ref":"#/$defs/bundledResource"}},"resourceSlots":{"type":"array","maxItems":16,"items":{"$ref":"#/$defs/resourceSlot"}},"execution":{"$ref":"#/$defs/execution"},"implementations":{"type":"array","minItems":1,"maxItems":8,"items":{"$ref":"#/$defs/implementation"}},"splitPolicy":{"enum":["copy","reset","reject"]}},"$defs":{"identifier":{"type":"string","minLength":1,"maxLength":96,"pattern":"^[A-Za-z][A-Za-z0-9_-]*$"},"relativePath":{"type":"string","minLength":1,"maxLength":512,"pattern":"^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\)[^\\u0000]+$"},"jsonValue":{"oneOf":[{"type":"null"},{"type":"boolean"},{"type":"number"},{"type":"string","maxLength":4096},{"type":"array","maxItems":1024,"items":{"$ref":"#/$defs/jsonValue"}},{"type":"object","maxProperties":128,"additionalProperties":{"$ref":"#/$defs/jsonValue"}}]},"display":{"type":"object","additionalProperties":false,"required":["name"],"properties":{"name":{"type":"string","minLength":1,"maxLength":128},"description":{"type":"string","maxLength":2048},"category":{"type":"string","maxLength":64},"tags":{"type":"array","maxItems":32,"uniqueItems":true,"items":{"type":"string","minLength":1,"maxLength":64}},"icon":{"$ref":"#/$defs/relativePath"},"thumbnail":{"$ref":"#/$defs/relativePath"},"preview":{"$ref":"#/$defs/relativePath"},"localizationPrefix":{"type":"string","maxLength":128}}},"port":{"type":"object","additionalProperties":false,"required":["id","direction","type","role","binding","required"],"properties":{"id":{"$ref":"#/$defs/identifier"},"direction":{"enum":["input","output"]},"type":{"enum":["visual-frame","mask","depth","motion-vectors"]},"role":{"enum":["source","from","to","auxiliary","result"]},"binding":{"enum":["host","instance"]},"required":{"type":"boolean"},"description":{"type":"string","maxLength":512}}},"parameter":{"type":"object","additionalProperties":false,"required":["id","type","default","animatable","affects","ui"],"properties":{"id":{"$ref":"#/$defs/identifier"},"type":{"enum":["boolean","integer","float","enum","vec2","vec3","vec4","color","angle","duration","gradient","curve","string"]},"default":{"$ref":"#/$defs/jsonValue"},"range":{"type":"object","additionalProperties":false,"properties":{"min":{"type":"number"},"max":{"type":"number"},"softMin":{"type":"number"},"softMax":{"type":"number"},"step":{"type":"number","exclusiveMinimum":0}}},"values":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string","minLength":1,"maxLength":96}},"unit":{"enum":["none","ratio","percent","px","degree","us","db","hz"]},"animatable":{"type":"boolean"},"interpolation":{"enum":["hold","linear","cubic-bezier","shortest-angle","linear-color"]},"affects":{"enum":["uniform","specialization","graph"]},"ui":{"type":"object","additionalProperties":false,"required":["control","group","order","label"],"properties":{"control":{"enum":["toggle","slider","number","select","segmented","color","point","curve","gradient","text"]},"group":{"type":"string","maxLength":96},"order":{"type":"integer"},"label":{"type":"string","minLength":1,"maxLength":128}}}}},"bundledResource":{"type":"object","additionalProperties":true,"required":["id","kind","path"],"properties":{"id":{"$ref":"#/$defs/identifier"},"kind":{"enum":["texture2d","texture3d","lut1d","lut3d","cube-texture","mask","binary-table"]},"path":{"$ref":"#/$defs/relativePath"}}},"resourceSlot":{"type":"object","additionalProperties":true,"required":["id","kind","required"],"properties":{"id":{"$ref":"#/$defs/identifier"},"kind":{"enum":["texture2d","texture3d","lut1d","lut3d","cube-texture","mask","binary-table"]},"required":{"type":"boolean"},"fallbackResourceId":{"$ref":"#/$defs/identifier"}}},"execution":{"type":"object","additionalProperties":false,"required":["color","alpha","resolution","spatialPadding","temporal","determinism","supports"],"properties":{"color":{"type":"object","additionalProperties":false,"required":["input","output"],"properties":{"input":{"const":"working-linear"},"output":{"const":"working-linear"}}},"alpha":{"type":"object","additionalProperties":false,"required":["input","output","preservesTransparency"],"properties":{"input":{"const":"premultiplied"},"output":{"const":"premultiplied"},"preservesTransparency":{"type":"boolean"}}},"resolution":{"type":"object","additionalProperties":false,"required":["policy"],"properties":{"policy":{"enum":["same-as-host","scale"]},"scale":{"type":"number","exclusiveMinimum":0,"maximum":4},"minimum":{"type":"object","additionalProperties":false,"required":["width","height"],"properties":{"width":{"type":"integer","minimum":1,"maximum":16384},"height":{"type":"integer","minimum":1,"maximum":16384}}}}},"spatialPadding":{"type":"object","additionalProperties":false,"required":["mode"],"properties":{"mode":{"enum":["none","fixed","parameter-bound"]},"pixels":{"type":"number","minimum":0,"maximum":4096},"parameter":{"$ref":"#/$defs/identifier"},"maximumPixels":{"type":"number","minimum":0,"maximum":4096}}},"temporal":{"type":"object","additionalProperties":false,"required":["pastUs","futureUs","stateful","seekPolicy"],"properties":{"pastUs":{"type":"integer","minimum":0},"futureUs":{"type":"integer","minimum":0},"stateful":{"type":"boolean"},"seekPolicy":{"enum":["stateless","reconstruct","reset-with-warning"]}}},"determinism":{"enum":["strict","backend-tolerant","non-deterministic"]},"supports":{"type":"object","additionalProperties":false,"required":["realtime","offline","alpha","hdr","tiled"],"properties":{"realtime":{"type":"boolean"},"offline":{"type":"boolean"},"alpha":{"type":"boolean"},"hdr":{"type":"boolean"},"tiled":{"type":"boolean"}}}}},"implementation":{"oneOf":[{"type":"object","additionalProperties":false,"required":["type","graph","nodeSet"],"properties":{"type":{"const":"graph"},"graph":{"$ref":"#/$defs/relativePath"},"nodeSet":{"type":"string","minLength":1,"maxLength":128}}},{"type":"object","additionalProperties":true,"required":["type","backend","abi","entryPoint"],"properties":{"type":{"const":"shader"},"backend":{"enum":["webgpu","webgl2"]},"abi":{"enum":["aelion-material-shader/1","aelion-material-webgl/1"]},"entryPoint":{"type":"string","minLength":1,"maxLength":128}}},{"type":"object","additionalProperties":true,"required":["type","module","abi"],"properties":{"type":{"const":"wasm"},"module":{"$ref":"#/$defs/relativePath"},"abi":{"const":"aelion-material-wasm/1"}}}]}}}`);
+export const materialGraphSchema = JSON.parse(String.raw `{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://schemas.aelion.dev/material/graph/v1.json","title":"Aelion Material Graph v1","type":"object","additionalProperties":false,"required":["$schema","graphVersion","nodeSet","nodes","outputs"],"properties":{"$schema":{"const":"https://schemas.aelion.dev/material/graph/v1.json"},"graphVersion":{"const":"1.0.0"},"nodeSet":{"type":"string","minLength":1,"maxLength":128},"nodes":{"type":"array","maxItems":128,"items":{"$ref":"#/$defs/node"}},"outputs":{"type":"object","minProperties":1,"maxProperties":8,"additionalProperties":{"$ref":"#/$defs/nodeReference"},"propertyNames":{"$ref":"#/$defs/localIdentifier"}}},"$defs":{"jsonValue":{"oneOf":[{"type":"null"},{"type":"boolean"},{"type":"number"},{"type":"string","maxLength":4096},{"type":"array","maxItems":1024,"items":{"$ref":"#/$defs/jsonValue"}},{"type":"object","maxProperties":128,"additionalProperties":{"$ref":"#/$defs/jsonValue"}}]},"localIdentifier":{"type":"string","minLength":1,"maxLength":96,"pattern":"^[A-Za-z][A-Za-z0-9_-]*$"},"node":{"type":"object","additionalProperties":false,"required":["id","type","typeVersion","inputs"],"properties":{"id":{"$ref":"#/$defs/localIdentifier"},"type":{"type":"string","minLength":1,"maxLength":128,"pattern":"^[a-z0-9]+(?:[._-][a-z0-9]+)*$"},"typeVersion":{"type":"string","pattern":"^[0-9]+\\.[0-9]+\\.[0-9]+$"},"inputs":{"type":"object","maxProperties":32,"additionalProperties":{"$ref":"#/$defs/graphValue"},"propertyNames":{"$ref":"#/$defs/localIdentifier"}},"config":{"type":"object","maxProperties":32,"additionalProperties":{"$ref":"#/$defs/jsonValue"}}}},"graphValue":{"oneOf":[{"type":"object","additionalProperties":false,"required":["value"],"properties":{"value":{"$ref":"#/$defs/jsonValue"}}},{"type":"object","additionalProperties":false,"required":["parameter"],"properties":{"parameter":{"$ref":"#/$defs/localIdentifier"}}},{"type":"object","additionalProperties":false,"required":["resource"],"properties":{"resource":{"$ref":"#/$defs/localIdentifier"}}},{"type":"object","additionalProperties":false,"required":["inputPort"],"properties":{"inputPort":{"$ref":"#/$defs/localIdentifier"}}},{"$ref":"#/$defs/nodeReference"},{"type":"object","additionalProperties":false,"required":["system"],"properties":{"system":{"enum":["sequenceTimeUs","itemTimeUs","itemDurationUs","normalizedItemTime","transitionProgress","frameIndex","frameDurationUs","outputSizePx","pixelSizeUv","workingColorSpace","qualityScale","randomSeed"]}}}]},"nodeReference":{"type":"object","additionalProperties":false,"required":["node","output"],"properties":{"node":{"$ref":"#/$defs/localIdentifier"},"output":{"$ref":"#/$defs/localIdentifier"}}}}}`);

package/dist/canonical.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from '@aelionsdk/core';
+/** Deterministic JSON serialization used for AMP file and manifest integrity. */
+export declare function canonicalizeMaterialJson(value: JsonValue): string;
+export declare function canonicalMaterialBytes(value: JsonValue): Uint8Array;
+export declare function sha256Hex(data: Uint8Array): Promise<string>;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAsBjD,iFAAiF;AACjF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAEjE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAEnE;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAIjE"}

package/dist/canonical.js

@@ -0,0 +1,33 @@
+function serialize(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new TypeError('Canonical JSON cannot contain non-finite numbers');
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(item => serialize(item)).join(',')}]`;
+    return `{${Object.keys(value)
+        .sort()
+        .map(key => {
+        const item = value[key];
+        if (item === undefined)
+            throw new TypeError('Canonical JSON cannot contain undefined');
+        return `${JSON.stringify(key)}:${serialize(item)}`;
+    })
+        .join(',')}}`;
+}
+/** Deterministic JSON serialization used for AMP file and manifest integrity. */
+export function canonicalizeMaterialJson(value) {
+    return serialize(value);
+}
+export function canonicalMaterialBytes(value) {
+    return new TextEncoder().encode(canonicalizeMaterialJson(value));
+}
+export async function sha256Hex(data) {
+    const source = new Uint8Array(data);
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', source);
+    return [...new Uint8Array(digest)].map(value => value.toString(16).padStart(2, '0')).join('');
+}

package/dist/catalog.d.ts

@@ -0,0 +1,24 @@
+import type { MaterialPackageReference } from './types.js';
+export type MaterialCatalogStatus = 'active' | 'deprecated' | 'revoked';
+export interface MaterialCatalogEntry {
+    readonly packageId: string;
+    readonly packageVersion: string;
+    readonly packageIntegrity: string;
+    readonly publisherId: string;
+    readonly materialIds: readonly string[];
+    readonly status: MaterialCatalogStatus;
+    readonly reason?: string;
+    readonly publishedAtMs: number;
+}
+/** Immutable-version local catalog model suitable for backing a remote marketplace adapter. */
+export declare class MaterialCatalog {
+    #private;
+    publish(entry: Omit<MaterialCatalogEntry, 'status' | 'reason'>): void;
+    setStatus(packageId: string, packageVersion: string, status: Exclude<MaterialCatalogStatus, 'active'>, reason: string): void;
+    resolve(reference: MaterialPackageReference): MaterialCatalogEntry;
+    list(options?: {
+        readonly publisherId?: string;
+        readonly includeRevoked?: boolean;
+    }): readonly MaterialCatalogEntry[];
+}
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAC;AAExE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAMD,+FAA+F;AAC/F,qBAAa,eAAe;;IAGnB,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAAG,IAAI;IAarE,SAAS,CACd,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,OAAO,CAAC,qBAAqB,EAAE,QAAQ,CAAC,EAChD,MAAM,EAAE,MAAM,GACb,IAAI;IAOA,OAAO,CAAC,SAAS,EAAE,wBAAwB,GAAG,oBAAoB;IAalE,IAAI,CACT,OAAO,GAAE;QAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GACjF,SAAS,oBAAoB,EAAE;CAanC"}

package/dist/catalog.js

@@ -0,0 +1,47 @@
+function keyOf(entry) {
+    return `${entry.packageId}\0${entry.packageVersion}`;
+}
+/** Immutable-version local catalog model suitable for backing a remote marketplace adapter. */
+export class MaterialCatalog {
+    #entries = new Map();
+    publish(entry) {
+        const key = keyOf(entry);
+        const existing = this.#entries.get(key);
+        if (existing !== undefined) {
+            if (existing.packageIntegrity === entry.packageIntegrity)
+                return;
+            throw new TypeError('MATERIAL_CATALOG_VERSION_IMMUTABLE');
+        }
+        if (new Set(entry.materialIds).size !== entry.materialIds.length) {
+            throw new TypeError('MATERIAL_CATALOG_DUPLICATE_MATERIAL');
+        }
+        this.#entries.set(key, { ...entry, materialIds: [...entry.materialIds], status: 'active' });
+    }
+    setStatus(packageId, packageVersion, status, reason) {
+        const key = keyOf({ packageId, packageVersion });
+        const entry = this.#entries.get(key);
+        if (entry === undefined)
+            throw new ReferenceError('MATERIAL_CATALOG_MISSING');
+        this.#entries.set(key, { ...entry, status, reason });
+    }
+    resolve(reference) {
+        const entry = this.#entries.get(keyOf(reference));
+        if (!entry?.materialIds.includes(reference.materialId)) {
+            throw new ReferenceError('MATERIAL_CATALOG_MISSING');
+        }
+        if (entry.packageIntegrity !== reference.packageIntegrity) {
+            throw new TypeError('MATERIAL_CATALOG_INTEGRITY_MISMATCH');
+        }
+        if (entry.status === 'revoked')
+            throw new TypeError(`MATERIAL_CATALOG_REVOKED: ${entry.reason}`);
+        return { ...entry, materialIds: [...entry.materialIds] };
+    }
+    list(options = {}) {
+        return [...this.#entries.values()]
+            .filter(entry => options.publisherId === undefined || entry.publisherId === options.publisherId)
+            .filter(entry => options.includeRevoked === true || entry.status !== 'revoked')
+            .sort((left, right) => left.packageId.localeCompare(right.packageId) ||
+            left.packageVersion.localeCompare(right.packageVersion))
+            .map(entry => ({ ...entry, materialIds: [...entry.materialIds] }));
+    }
+}

package/dist/composition.d.ts

@@ -0,0 +1,42 @@
+import type { JsonValue } from '@aelionsdk/core';
+import type { MaterialDefinition, MaterialPackageReference } from './types.js';
+export interface MaterialCompositionSlot {
+    readonly id: string;
+    readonly order: number;
+    readonly enabled: boolean;
+    readonly reference: MaterialPackageReference;
+    readonly definition: MaterialDefinition;
+    readonly parameters: Readonly<Record<string, JsonValue>>;
+}
+export interface MaterialFusionGroup {
+    readonly slotIds: readonly string[];
+    readonly fused: boolean;
+    readonly barrierReason?: string;
+}
+export interface MaterialCompositionPlan {
+    readonly slots: readonly MaterialCompositionSlot[];
+    readonly fusionGroups: readonly MaterialFusionGroup[];
+    readonly cacheKey: string;
+    readonly qualityScale: number;
+}
+export declare function createMaterialCompositionPlan(slots: readonly MaterialCompositionSlot[], options: {
+    readonly qualityScale?: number;
+    readonly outputWidth: number;
+    readonly outputHeight: number;
+    readonly workingColorSpace: string;
+    readonly maxFusedPasses?: number;
+}): Promise<MaterialCompositionPlan>;
+export interface AdaptiveMaterialQualityOptions {
+    readonly targetFrameMs: number;
+    readonly levels?: readonly number[];
+    readonly recoveryFrames?: number;
+}
+/** Hysteresis controller for preview quality; offline rendering should always use scale 1. */
+export declare class AdaptiveMaterialQualityController {
+    #private;
+    constructor(options: AdaptiveMaterialQualityOptions);
+    get qualityScale(): number;
+    reportFrame(frameMs: number): number;
+    reset(): void;
+}
+//# sourceMappingURL=composition.d.ts.map

package/dist/composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE/E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,wBAAwB,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACnD,QAAQ,CAAC,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AA8DD,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,SAAS,uBAAuB,EAAE,EACzC,OAAO,EAAE;IACP,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,GACA,OAAO,CAAC,uBAAuB,CAAC,CA6ClC;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,8FAA8F;AAC9F,qBAAa,iCAAiC;;gBASzB,OAAO,EAAE,8BAA8B;IAqB1D,IAAW,YAAY,IAAI,MAAM,CAIhC;IAEM,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAoBpC,KAAK,IAAI,IAAI;CAMrB"}

package/dist/composition.js

@@ -0,0 +1,169 @@
+import { canonicalMaterialBytes, sha256Hex } from './canonical.js';
+function fusionBarrier(slot) {
+    const { definition } = slot;
+    if (definition.implementations.every(value => value.type !== 'graph'))
+        return 'native-code';
+    if (definition.execution.temporal.stateful)
+        return 'stateful';
+    if (definition.execution.temporal.pastUs > 0 || definition.execution.temporal.futureUs > 0) {
+        return 'temporal-neighborhood';
+    }
+    if (definition.execution.resolution.policy !== 'same-as-host')
+        return 'resolution-change';
+    if (definition.execution.spatialPadding.mode !== 'none')
+        return 'spatial-padding';
+    if (definition.execution.determinism === 'non-deterministic')
+        return 'non-deterministic';
+    return undefined;
+}
+function validateSlots(slots) {
+    if (slots.length > 64)
+        throw new RangeError('Material composition supports at most 64 slots');
+    const ids = new Set();
+    for (const slot of slots) {
+        if (slot.id.length === 0 || ids.has(slot.id))
+            throw new TypeError('MATERIAL_SLOT_ID_INVALID');
+        if (!Number.isSafeInteger(slot.order))
+            throw new RangeError('MATERIAL_SLOT_ORDER_INVALID');
+        ids.add(slot.id);
+    }
+    return slots
+        .filter(value => value.enabled)
+        .slice()
+        .sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+}
+function buildFusionGroups(slots, maxFusedPasses) {
+    const groups = [];
+    let current = [];
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        groups.push({ slotIds: current, fused: current.length > 1 });
+        current = [];
+    };
+    for (const slot of slots) {
+        const barrier = fusionBarrier(slot);
+        if (barrier !== undefined) {
+            flush();
+            groups.push({ slotIds: [slot.id], fused: false, barrierReason: barrier });
+            continue;
+        }
+        if (current.length >= maxFusedPasses)
+            flush();
+        current.push(slot.id);
+    }
+    flush();
+    return groups;
+}
+function canonicalParameters(parameters) {
+    return Object.fromEntries(Object.entries(parameters).sort(([left], [right]) => left.localeCompare(right)));
+}
+export async function createMaterialCompositionPlan(slots, options) {
+    const ordered = validateSlots(slots);
+    const qualityScale = options.qualityScale ?? 1;
+    const maxFusedPasses = options.maxFusedPasses ?? 8;
+    if (!(qualityScale > 0 && qualityScale <= 1))
+        throw new RangeError('QUALITY_SCALE_INVALID');
+    if (!Number.isSafeInteger(maxFusedPasses) || maxFusedPasses <= 0 || maxFusedPasses > 16) {
+        throw new RangeError('MAX_FUSED_PASSES_INVALID');
+    }
+    if (!Number.isSafeInteger(options.outputWidth) ||
+        !Number.isSafeInteger(options.outputHeight) ||
+        options.outputWidth <= 0 ||
+        options.outputHeight <= 0) {
+        throw new RangeError('MATERIAL_OUTPUT_SIZE_INVALID');
+    }
+    const fusionGroups = buildFusionGroups(ordered, maxFusedPasses);
+    const keyValue = {
+        protocol: 'aelion-material-composition/1',
+        output: {
+            width: options.outputWidth,
+            height: options.outputHeight,
+            workingColorSpace: options.workingColorSpace,
+            qualityScale,
+        },
+        slots: ordered.map(slot => ({
+            id: slot.id,
+            packageId: slot.reference.packageId,
+            packageVersion: slot.reference.packageVersion,
+            packageIntegrity: slot.reference.packageIntegrity,
+            materialId: slot.reference.materialId,
+            parameters: canonicalParameters(slot.parameters),
+        })),
+        fusionGroups: fusionGroups.map(group => ({
+            slotIds: [...group.slotIds],
+            fused: group.fused,
+            ...(group.barrierReason === undefined ? {} : { barrierReason: group.barrierReason }),
+        })),
+    };
+    return {
+        slots: ordered,
+        fusionGroups,
+        cacheKey: `sha256:${await sha256Hex(canonicalMaterialBytes(keyValue))}`,
+        qualityScale,
+    };
+}
+/** Hysteresis controller for preview quality; offline rendering should always use scale 1. */
+export class AdaptiveMaterialQualityController {
+    #targetFrameMs;
+    #levels;
+    #recoveryFrames;
+    #levelIndex = 0;
+    #averageFrameMs = 0;
+    #samples = 0;
+    #underBudgetFrames = 0;
+    constructor(options) {
+        if (!Number.isFinite(options.targetFrameMs) || options.targetFrameMs <= 0) {
+            throw new RangeError('TARGET_FRAME_TIME_INVALID');
+        }
+        const levels = [...(options.levels ?? [1, 0.75, 0.5, 0.25])];
+        const invalidLevel = levels.some((value, index) => {
+            const previous = levels[index - 1];
+            return !(value > 0 && value <= 1) || (previous !== undefined && value >= previous);
+        });
+        if (levels.length === 0 || invalidLevel) {
+            throw new RangeError('QUALITY_LEVELS_INVALID');
+        }
+        const recoveryFrames = options.recoveryFrames ?? 30;
+        if (!Number.isSafeInteger(recoveryFrames) || recoveryFrames <= 0) {
+            throw new RangeError('RECOVERY_FRAMES_INVALID');
+        }
+        this.#targetFrameMs = options.targetFrameMs;
+        this.#levels = levels;
+        this.#recoveryFrames = recoveryFrames;
+    }
+    get qualityScale() {
+        const value = this.#levels[this.#levelIndex];
+        if (value === undefined)
+            throw new RangeError('QUALITY_LEVELS_INVALID');
+        return value;
+    }
+    reportFrame(frameMs) {
+        if (!Number.isFinite(frameMs) || frameMs < 0)
+            throw new RangeError('FRAME_TIME_INVALID');
+        this.#averageFrameMs =
+            this.#samples === 0 ? frameMs : this.#averageFrameMs * 0.8 + frameMs * 0.2;
+        this.#samples++;
+        if (this.#averageFrameMs > this.#targetFrameMs * 1.1) {
+            this.#levelIndex = Math.min(this.#levelIndex + 1, this.#levels.length - 1);
+            this.#underBudgetFrames = 0;
+        }
+        else if (this.#averageFrameMs < this.#targetFrameMs * 0.75) {
+            this.#underBudgetFrames++;
+            if (this.#underBudgetFrames >= this.#recoveryFrames) {
+                this.#levelIndex = Math.max(0, this.#levelIndex - 1);
+                this.#underBudgetFrames = 0;
+            }
+        }
+        else {
+            this.#underBudgetFrames = 0;
+        }
+        return this.qualityScale;
+    }
+    reset() {
+        this.#levelIndex = 0;
+        this.#averageFrameMs = 0;
+        this.#samples = 0;
+        this.#underBudgetFrames = 0;
+    }
+}

package/dist/definition-builder.d.ts

@@ -0,0 +1,48 @@
+import type { JsonValue } from '@aelionsdk/core';
+import { type AuthoredMaterial, type BundledMaterialResource, type MaterialDefinition, type MaterialDisplay, type MaterialExecutionContract, type MaterialImplementation, type MaterialKind, type MaterialParameter, type MaterialPort, type MaterialResourceSlot, type MaterialScope } from './types.js';
+import type { MaterialGraph } from '@aelionsdk/material-compiler';
+export interface MaterialDefinitionBuilderOptions {
+    readonly id: string;
+    readonly kind: MaterialKind;
+    readonly display: MaterialDisplay;
+    readonly scopes?: readonly MaterialScope[];
+}
+export declare class MaterialDefinitionBuilder {
+    #private;
+    constructor(options: MaterialDefinitionBuilderOptions);
+    port(port: MaterialPort): this;
+    parameter(parameter: MaterialParameter): this;
+    floatParameter(id: string, options: {
+        readonly default: number;
+        readonly min?: number;
+        readonly max?: number;
+        readonly step?: number;
+        readonly label?: string;
+        readonly group?: string;
+        readonly order?: number;
+        readonly unit?: MaterialParameter['unit'];
+        readonly animatable?: boolean;
+        readonly affects?: MaterialParameter['affects'];
+    }): this;
+    enumParameter(id: string, options: {
+        readonly default: string;
+        readonly values: readonly string[];
+        readonly label?: string;
+        readonly group?: string;
+        readonly order?: number;
+        readonly affects?: MaterialParameter['affects'];
+    }): this;
+    bundledResource(resource: BundledMaterialResource): this;
+    resourceSlot(resource: MaterialResourceSlot): this;
+    graph(path: string, graph: MaterialGraph): this;
+    /** Adds trusted executable code. The package still requires explicit host authorization. */
+    trustedImplementation(implementation: Exclude<MaterialImplementation, {
+        type: 'graph';
+    }>): this;
+    execution(contract: MaterialExecutionContract): this;
+    splitPolicy(policy: MaterialDefinition['splitPolicy']): this;
+    build(): AuthoredMaterial;
+}
+export declare function materialDefinition(options: MaterialDefinitionBuilderOptions): MaterialDefinitionBuilder;
+export type MaterialParameterDefault = JsonValue;
+//# sourceMappingURL=definition-builder.d.ts.map

package/dist/definition-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-builder.d.ts","sourceRoot":"","sources":["../src/definition-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACnB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AAiDD,qBAAa,yBAAyB;;gBAYxB,OAAO,EAAE,gCAAgC;IAKrD,IAAI,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAK9B,SAAS,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI;IAK7C,cAAc,CACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QACP,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;KACjD,GACA,IAAI;IA2BP,aAAa,CACX,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QACP,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;QACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;KACjD,GACA,IAAI;IAkBP,eAAe,CAAC,QAAQ,EAAE,uBAAuB,GAAG,IAAI;IAKxD,YAAY,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAKlD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI;IAO/C,4FAA4F;IAC5F,qBAAqB,CAAC,cAAc,EAAE,OAAO,CAAC,sBAAsB,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,GAAG,IAAI;IAK/F,SAAS,CAAC,QAAQ,EAAE,yBAAyB,GAAG,IAAI;IAKpD,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,aAAa,CAAC,GAAG,IAAI;IAK5D,KAAK,IAAI,gBAAgB;CAuB1B;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,gCAAgC,GACxC,yBAAyB,CAE3B;AAGD,MAAM,MAAM,wBAAwB,GAAG,SAAS,CAAC"}

package/dist/definition-builder.js

@@ -0,0 +1,159 @@
+import { MATERIAL_DEFINITION_SCHEMA, MATERIAL_NODE_SET, MATERIAL_PROTOCOL_VERSION, } from './types.js';
+const DEFAULT_EXECUTION = {
+    color: { input: 'working-linear', output: 'working-linear' },
+    alpha: {
+        input: 'premultiplied',
+        output: 'premultiplied',
+        preservesTransparency: true,
+    },
+    resolution: { policy: 'same-as-host' },
+    spatialPadding: { mode: 'none' },
+    temporal: { pastUs: 0, futureUs: 0, stateful: false, seekPolicy: 'stateless' },
+    determinism: 'strict',
+    supports: { realtime: true, offline: true, alpha: true, hdr: false, tiled: true },
+};
+function hostPort(id, direction, role) {
+    return { id, direction, type: 'visual-frame', role, binding: 'host', required: true };
+}
+function defaultPorts(kind) {
+    switch (kind) {
+        case 'visual-filter':
+            return [hostPort('source', 'input', 'source'), hostPort('result', 'output', 'result')];
+        case 'visual-transition':
+            return [
+                hostPort('from', 'input', 'from'),
+                hostPort('to', 'input', 'to'),
+                hostPort('result', 'output', 'result'),
+            ];
+        case 'visual-generator':
+            return [hostPort('result', 'output', 'result')];
+        case 'visual-effect':
+            return [hostPort('source', 'input', 'source'), hostPort('result', 'output', 'result')];
+    }
+}
+function defaultScopes(kind) {
+    return kind === 'visual-transition'
+        ? ['transition']
+        : kind === 'visual-generator'
+            ? ['item']
+            : ['source', 'item', 'track', 'sequence'];
+}
+export class MaterialDefinitionBuilder {
+    #options;
+    #ports;
+    #parameters = [];
+    #bundledResources = [];
+    #resourceSlots = [];
+    #implementations = [];
+    #execution = DEFAULT_EXECUTION;
+    #splitPolicy = 'copy';
+    #graph;
+    #graphPath;
+    constructor(options) {
+        this.#options = options;
+        this.#ports = defaultPorts(options.kind);
+    }
+    port(port) {
+        this.#ports.push(port);
+        return this;
+    }
+    parameter(parameter) {
+        this.#parameters.push(parameter);
+        return this;
+    }
+    floatParameter(id, options) {
+        const range = options.min === undefined && options.max === undefined && options.step === undefined
+            ? undefined
+            : {
+                ...(options.min === undefined ? {} : { min: options.min, softMin: options.min }),
+                ...(options.max === undefined ? {} : { max: options.max, softMax: options.max }),
+                ...(options.step === undefined ? {} : { step: options.step }),
+            };
+        return this.parameter({
+            id,
+            type: 'float',
+            default: options.default,
+            ...(range === undefined ? {} : { range }),
+            ...(options.unit === undefined ? {} : { unit: options.unit }),
+            animatable: options.animatable ?? true,
+            interpolation: 'linear',
+            affects: options.affects ?? 'uniform',
+            ui: {
+                control: 'slider',
+                group: options.group ?? 'main',
+                order: options.order ?? this.#parameters.length,
+                label: options.label ?? id,
+            },
+        });
+    }
+    enumParameter(id, options) {
+        return this.parameter({
+            id,
+            type: 'enum',
+            default: options.default,
+            values: options.values,
+            animatable: false,
+            interpolation: 'hold',
+            affects: options.affects ?? 'specialization',
+            ui: {
+                control: 'select',
+                group: options.group ?? 'main',
+                order: options.order ?? this.#parameters.length,
+                label: options.label ?? id,
+            },
+        });
+    }
+    bundledResource(resource) {
+        this.#bundledResources.push(resource);
+        return this;
+    }
+    resourceSlot(resource) {
+        this.#resourceSlots.push(resource);
+        return this;
+    }
+    graph(path, graph) {
+        this.#graphPath = path;
+        this.#graph = graph;
+        this.#implementations.push({ type: 'graph', graph: path, nodeSet: MATERIAL_NODE_SET });
+        return this;
+    }
+    /** Adds trusted executable code. The package still requires explicit host authorization. */
+    trustedImplementation(implementation) {
+        this.#implementations.push(implementation);
+        return this;
+    }
+    execution(contract) {
+        this.#execution = contract;
+        return this;
+    }
+    splitPolicy(policy) {
+        this.#splitPolicy = policy;
+        return this;
+    }
+    build() {
+        const definition = {
+            $schema: MATERIAL_DEFINITION_SCHEMA,
+            protocolVersion: MATERIAL_PROTOCOL_VERSION,
+            id: this.#options.id,
+            kind: this.#options.kind,
+            display: this.#options.display,
+            scopes: this.#options.scopes ?? defaultScopes(this.#options.kind),
+            ports: [...this.#ports],
+            parameters: [...this.#parameters],
+            bundledResources: [...this.#bundledResources],
+            resourceSlots: [...this.#resourceSlots],
+            execution: this.#execution,
+            implementations: [...this.#implementations],
+            splitPolicy: this.#splitPolicy,
+        };
+        return {
+            definition,
+            ...(this.#graph === undefined ? {} : { graph: this.#graph }),
+            definitionPath: `materials/${this.#options.id}.material.json`,
+            ...(this.#graphPath === undefined ? {} : { graphPath: this.#graphPath }),
+        };
+    }
+}
+export function materialDefinition(options) {
+    return new MaterialDefinitionBuilder(options);
+}