@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/skills/2d-pixel-perfect/references/api-reference.md

@@ -0,0 +1,81 @@
+# PixelPerfect Skill — Full API Reference
+
+## URP `PixelPerfectCamera` (`UnityEngine.Rendering.Universal`)
+API is identical since Unity 2023.2 through latest Unity 6 versions.
+
+### Properties
+
+| Property | Type | Access | Description |
+|---|---|---|---|
+| `assetsPPU` | `int` | get/set | Must match Pixels Per Unit on all sprites in scene |
+| `refResolutionX` | `int` | get/set | Base resolution width |
+| `refResolutionY` | `int` | get/set | Base resolution height |
+| `cropFrame` | `CropFrame` | get/set | How to handle aspect ratio differences |
+| `gridSnapping` | `GridSnapping` | get/set | Snapping mode — replaces old `pixelSnapping`/`upscaleRT` bools |
+| `orthographicSize` | `float` | get only | PP Camera's calculated ortho size (different from `Camera.orthographicSize`) |
+| `pixelRatio` | `int` | get only | Actual scale factor applied (e.g. 6 on 1080p with 320×180 ref res) |
+| `requiresUpscalePass` | `bool` | get only | True when `gridSnapping = UpscaleRenderTexture` |
+
+### Methods
+
+| Method | Returns | Description |
+|---|---|---|
+| `RoundToPixel(Vector3)` | `Vector3` | Snaps world-space position to pixel grid. Adapts to current `gridSnapping`. |
+| `CorrectCinemachineOrthoSize(float)` | `float` | Returns nearest pixel-perfect ortho size. Used by the Cinemachine extension. |
+
+### Static
+
+**`UnityEngine.U2D.PixelPerfectRendering.pixelSnapSpacing`** (static float) — world-space size of one screen pixel. Formula: `Camera.orthographicSize * 2f / Camera.pixelHeight`. Set manually in custom setups that bypass the PP Camera component (e.g. HDRP fallback, custom SRP).
+
+---
+
+## `GridSnapping` Enum
+
+| Value | Old standalone equivalent | Behaviour |
+|---|---|---|
+| `None` | `pixelSnapping = false`, `upscaleRT = false` | No snapping. |
+| `PixelSnapping` | `pixelSnapping = true` | Snaps SpriteRenderers at render-time. Transforms stay at float precision. |
+| `UpscaleRenderTexture` | `upscaleRT = true` | Renders at ref res then upscales. Incompatible with post-processing and UI text. |
+
+---
+
+## `CropFrame` Enum
+
+| Value | Old standalone equivalent | Behaviour |
+|---|---|---|
+| `None` | both false | No cropping. Scene stretches to fill screen. |
+| `Pillarbox` | `cropFrameX = true, cropFrameY = false` | Black bars left and right. |
+| `Letterbox` | `cropFrameX = false, cropFrameY = true` | Black bars top and bottom. |
+| `Windowbox` | both true, `stretchFill = false` | Black bars all sides. Safest default. |
+| `StretchFill` | both true, `stretchFill = true` | Fills screen maintaining aspect ratio. Enables component-level Filter Mode. |
+
+**Filter Mode** (only active when `StretchFill` — separate from per-sprite texture Filter Mode):
+- `Retro AA` — default. Integer upscale to nearest multiple, then bilinear to screen. Recommended.
+- `Point` — nearest-neighbour all the way to screen. Can lose pixel-perfectness at non-integer scale factors.
+
+---
+
+## Recommended Configurations
+
+| Use case | `gridSnapping` | `cropFrame` | Notes |
+|---|---|---|---|
+| Standard pixel art | `PixelSnapping` | `Windowbox` | Safe default. Compatible with post-processing and UI. |
+| Authentic low-res look | `UpscaleRenderTexture` | `Windowbox` | No post-processing. Separate UI camera required. |
+| Performance on 4K/HiDPI | `UpscaleRenderTexture` | `Windowbox` | Renders fewer pixels. Same UI caveat. |
+| Full-screen stretch | `PixelSnapping` | `StretchFill` | Use `Retro AA` filter, not Point. |
+
+---
+
+## Standalone Built-in (`UnityEngine.U2D.PixelPerfectCamera`)
+All booleans, no enums. No `RoundToPixel`, `CorrectCinemachineOrthoSize`, `requiresUpscalePass`, or `orthographicSize`.
+
+| Property | Type | Constraint |
+|---|---|---|
+| `assetsPPU` | `int` | — |
+| `refResolutionX` / `refResolutionY` | `int` | — |
+| `pixelSnapping` | `bool` | Silently ignored when `upscaleRT = true` |
+| `upscaleRT` | `bool` | When true, `pixelSnapping` has no effect |
+| `cropFrameX` | `bool` | Black bars left/right |
+| `cropFrameY` | `bool` | Black bars top/bottom |
+| `stretchFill` | `bool` | Only functional when **both** `cropFrameX` and `cropFrameY` are `true` |
+| `pixelRatio` | `int` readonly | Same semantics as URP `pixelRatio` |

package/skills/2d-pixel-perfect/references/camera-setup-builtin.cs

@@ -0,0 +1,40 @@
+// PixelPerfect Skill — Built-in Standalone Camera Setup
+// -------------------------------------------------------
+// Assembly: Unity.2D.PixelPerfect
+using UnityEngine;
+using UnityEngine.U2D;
+
+namespace PixelPerfect
+{
+    public static class CameraSetupBuiltIn
+    {
+        public static PixelPerfectCamera ConfigureCamera(Camera camera, int refResX, int refResY, int targetPPU)
+        {
+            var pp = camera.gameObject.GetComponent<PixelPerfectCamera>()
+                  ?? camera.gameObject.AddComponent<PixelPerfectCamera>();
+
+            // Same base settings as URP
+            camera.orthographic = true;
+            camera.orthographicSize = (refResY / 2f) / targetPPU;
+            camera.allowHDR = camera.allowMSAA = camera.allowDynamicResolution = false;
+            QualitySettings.antiAliasing = 0;
+            QualitySettings.anisotropicFiltering = AnisotropicFiltering.Disable;
+
+            pp.assetsPPU      = targetPPU;
+            pp.refResolutionX = refResX;
+            pp.refResolutionY = refResY;
+            pp.pixelSnapping  = true;    // silently ignored when upscaleRT = true
+            pp.upscaleRT      = false;
+            pp.cropFrameX     = true;    // black bars left/right
+            pp.cropFrameY     = true;    // black bars top/bottom — both true = Windowbox equivalent
+            pp.stretchFill    = false;   // only functional when BOTH cropFrameX and cropFrameY are true
+
+            // Read-only: pp.pixelRatio (int) — same semantics as URP pixelRatio
+            //
+            // Note: No RoundToPixel, CorrectCinemachineOrthoSize, requiresUpscalePass,
+            //       or orthographicSize on the standalone component.
+
+            return pp;
+        }
+    }
+}

package/skills/2d-pixel-perfect/references/camera-setup-urp.cs

@@ -0,0 +1,49 @@
+// PixelPerfect Skill — URP Camera Setup
+// ---------------------------------------
+using UnityEngine;
+using UnityEngine.Rendering.Universal;
+using UnityEngine.U2D;
+
+namespace PixelPerfect
+{
+    public static class CameraSetupURP
+    {
+        // orthographicSize formula: (refResY / 2) / PPU
+        // e.g. 320x180 at 16 PPU → 90 / 16 = 5.625
+        public static PixelPerfectCamera ConfigureCamera(Camera camera, int refResX, int refResY, int targetPPU)
+        {
+            var pp = camera.gameObject.GetComponent<PixelPerfectCamera>()
+                  ?? camera.gameObject.AddComponent<PixelPerfectCamera>();
+
+            camera.orthographic = true;
+            camera.orthographicSize = (refResY / 2f) / targetPPU;
+            camera.allowHDR = camera.allowMSAA = camera.allowDynamicResolution = false;
+            QualitySettings.antiAliasing = 0;
+            QualitySettings.anisotropicFiltering = AnisotropicFiltering.Disable;
+
+            pp.assetsPPU      = targetPPU;
+            pp.refResolutionX = refResX;
+            pp.refResolutionY = refResY;
+            pp.gridSnapping   = PixelPerfectCamera.GridSnapping.PixelSnapping; // or UpscaleRenderTexture
+            pp.cropFrame      = PixelPerfectCamera.CropFrame.Windowbox;        // or None/Pillarbox/Letterbox/StretchFill
+
+            // Read-only properties (for reference):
+            //   pp.pixelRatio          (int)   — actual scale factor applied (e.g. 6 on 1080p with 320x180 ref res)
+            //   pp.requiresUpscalePass (bool)  — true when gridSnapping = UpscaleRenderTexture
+            //   pp.orthographicSize    (float) — PP-calculated ortho size (different from Camera.orthographicSize)
+
+            // Utility methods (for reference):
+            //   pp.RoundToPixel(Vector3)              — pixel-grid snapping for custom camera controllers
+            //   pp.CorrectCinemachineOrthoSize(float) — used by Cinemachine extension
+
+            return pp;
+        }
+
+        // For custom setups that bypass the PP Camera component (e.g. HDRP fallback, custom SRP):
+        // set pixelSnapSpacing manually to enable snapping at the renderer level.
+        public static void SetManualPixelSnapSpacing(Camera camera)
+        {
+            PixelPerfectRendering.pixelSnapSpacing = camera.orthographicSize * 2f / camera.pixelHeight;
+        }
+    }
+}

package/skills/2d-pixel-perfect/references/pipeline-detection.cs

@@ -0,0 +1,50 @@
+// PixelPerfect Skill — Pipeline Detection
+// ----------------------------------------
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.U2D;
+
+namespace PixelPerfect
+{
+    public enum PipelineType { BuiltIn, URP, HDRP, Custom }
+
+    public static class PipelineDetection
+    {
+        // GraphicsSettings.currentRenderPipeline is always up to date — safe to call on startup.
+        // Do NOT use RenderPipelineManager.currentPipeline: it is null until at least one frame renders.
+        public static PipelineType DetectPipeline()
+        {
+            var rpa = GraphicsSettings.currentRenderPipeline;
+            if (rpa == null) return PipelineType.BuiltIn;
+
+            // Use FullName (includes namespace) — more stable than Name, which strips the namespace.
+            // URP:  UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset
+            // HDRP: UnityEngine.Rendering.HighDefinition.HDRenderPipelineAsset
+            var fullName = rpa.GetType().FullName ?? string.Empty;
+            if (fullName.Contains("Universal"))      return PipelineType.URP;
+            if (fullName.Contains("HighDefinition")) return PipelineType.HDRP;
+            return PipelineType.Custom;
+        }
+
+        public static System.Type GetPixelPerfectCameraType(PipelineType pipeline)
+        {
+            if (pipeline == PipelineType.URP)
+            {
+                var t = System.Type.GetType(
+                    "UnityEngine.Rendering.Universal.PixelPerfectCamera, " +
+                    "Unity.RenderPipelines.Universal.2D.Runtime");
+                if (t != null) return t;
+                Debug.LogWarning("URP detected but PixelPerfectCamera not found. Is the 2D Renderer installed?");
+            }
+            // Assembly name confirmed from asmdef — no "Runtime" suffix
+            return System.Type.GetType("UnityEngine.U2D.PixelPerfectCamera, Unity.2D.PixelPerfect");
+        }
+
+        // Migration diagnostic: check for the wrong component type on a URP camera
+        public static bool HasPipelineMismatch(Camera camera)
+        {
+            return DetectPipeline() == PipelineType.URP
+                && camera.GetComponent<PixelPerfectCamera>() != null;
+        }
+    }
+}

package/skills/2d-pixel-perfect/references/sprite-settings.cs

@@ -0,0 +1,37 @@
+// PixelPerfect Skill — Sprite Import Settings (Editor-only)
+// ----------------------------------------------------------
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace PixelPerfect.Editor
+{
+    public static class SpriteImportUtility
+    {
+        public static TextureImporter GetImporter(Sprite sprite)
+        {
+            if (sprite == null) return null;
+            var path = AssetDatabase.GetAssetPath(sprite);
+            if (string.IsNullOrEmpty(path)) return null;
+            return AssetImporter.GetAtPath(path) as TextureImporter;
+        }
+
+        public static bool FixSpriteImportSettings(Sprite sprite, int targetPPU)
+        {
+            var importer = GetImporter(sprite);
+            if (importer == null) { Debug.LogWarning($"No importer for: {sprite?.name}"); return false; }
+
+            importer.filterMode = FilterMode.Point;
+            importer.mipmapEnabled = false;
+            importer.textureCompression = TextureImporterCompression.Uncompressed;
+            importer.spritePixelsPerUnit = targetPPU;
+            AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(sprite), ImportAssetOptions.ForceUpdate);
+            return true;
+        }
+
+        // After batch-fixing multiple sprites, always flush with:
+        //   AssetDatabase.SaveAssets();
+        //   AssetDatabase.Refresh();
+    }
+}
+#endif

package/skills/asset-transformer-toolkit/SECURITY.md

@@ -0,0 +1,15 @@
+# Security notes: asset-transformer-toolkit
+
+This skill has the agent write C# and run it inside the user's live Unity Editor, to create and edit Asset Transformer RuleSets. It doesn't say which command runs the code; with the `unity` CLI that is `unity command script eval`. Automated skill scanners flag running generated code as a powerful capability. It is intentional, and it is limited by the safeguards below.
+
+## Accepted risks
+
+| Risk | Capability | Why it is accepted |
+|---|---|---|
+| `SEC_POWER_CAP` | Runs agent-written C# in the user's live Editor | It only reaches the Editor the user already has open, on their own machine, as that user, so it grants nothing they couldn't do themselves. The code only edits RuleSet assets in the user's own project. No code fetched from a remote source is run. |
+
+## Mitigations
+
+- **Only the user's own Editor.** The code runs in the Editor open on this machine. It can't reach another machine or another user's Editor.
+- **Narrow purpose.** The scripts create or modify RuleSet assets through the documented Asset Transformer API, then validate them against the checklist in `references/`.
+- **No remote code.** The agent runs C# it writes from this skill's own recipes. Nothing downloaded from outside is executed.

package/skills/asset-transformer-toolkit/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: asset-transformer-toolkit
+description: >-
+  In the Unity Editor, imports 3D models and point clouds with Asset Transformer Toolkit (formerly
+  Pixyz), and creates, edits, and runs RuleSets, Actions, and LODs. Use for Pixyz imports in a Unity
+  project, not for converting files from the shell.
+required_packages:
+    com.unity.industry.toolkit: ">=4.0.0"
+---
+### Before you start: check the package version
+This skill needs Asset Transformer Toolkit 4.0.0 or later (`com.unity.industry.toolkit`). Earlier versions don't have the `ATTAssistantUtilities` API every workflow below relies on.
+
+1. Read the resolved version of `com.unity.industry.toolkit` from `Packages/packages-lock.json` (fall back to `Packages/manifest.json`).
+2. **Not installed:** tell the user this workflow needs Asset Transformer Toolkit 4.0 or later, which is an entitled Unity package they may need access to through their Unity plan, and stop. Don't add it to the manifest yourself.
+3. **Installed below 4.0.0:** tell the user which version you found and that 4.0 or later is required, and ask before upgrading. Don't fall back to older APIs, raw C# against internal types, or reflection.
+4. **4.0.0 or later:** continue.
+
+### API Reference
+Tool functions are provided by `Unity.Pixyz.Plugin4Unity.Editor.AI.ATTAssistantUtilities`. They are documented inline in each reference file below alongside the classes they operate on.
+
+### Technical Notes
+Pixyz Plugin is the former name of Asset Transformer Toolkit. Prefer using the term 'Asset Transformer Toolkit' when addressing the user, unless the user is using the term 'Pixyz'
+Most classes and code are in the Unity.Pixyz.Plugin4Unity.Editor assembly.
+Asset Transformer Toolkit is NOT the same thing as Asset Transformer Studio/Pixyz Studio. NEVER rely on information about Asset Transformer Studio.
+
+### Importers
+Asset Transformer Toolkit can import 3D file from outside the project.
+When modifying Importers, NEVER assume it should be immediately followed by a reimport. The import process can be very long, so it must only be launched when the user requests it.
+Modify fields in Importers using the ScriptableObject API. NEVER use reflection to access or modify Importer fields — reflection is not available.
+To create a Pixyz/Asset Transformer Toolkit Importer for importing a file, or to reimport a model using an existing ImporterScriptableObject, read [references/create-importer](references/create-importer.md)
+
+### RuleSets and Actions
+Read [references/rulesets-and-actions](references/rulesets-and-actions.md)
+Read [references/ruleset-api](references/ruleset-api.md) when the RuleSet API is needed.
+Read [references/rule-api](references/rule-api.md) when the Rule API is needed.
+Read [references/ruleblock-api](references/ruleblock-api.md) when the RuleBlock API is needed, including `ActionBase.Id` for constructing `RuleBlock` instances.
+
+### Levels of Detail
+Read [references/lods](references/lods.md)

package/skills/asset-transformer-toolkit/references/create-importer.md

@@ -0,0 +1,121 @@
+## Contents
+- [Workflow steps](#workflow) — Pre-Flight, Create Importer, Configure Importer, Import
+- [Importer utility functions](#importer-utility-functions) — `EnsureImporterSaveFolder`, `GetImporterTypes`, `GetImporterProperties`, `CreateImporter`, `CanImportFile`, `ImportFile`
+
+---
+
+If a new Importer does not need to be created, skip to Step 3
+
+### Step 1: Pre-Flight
+- Check whether an importer asset already exists for this file. If it does, skip to Step 3.
+- Verify the file to be imported exists.
+- Verify the file type is supported by Pixyz/Asset Transformer Toolkit using `ATTAssistantUtilities.CanImportFile()`.
+- Check what kind of file (eg. point cloud, CAD) is it. Find the Importer type that would best match it.
+
+### Step 2: Create Importer
+- Create the appropriate Importer asset with the path to the file to be imported. The path must be relative to the Application.dataPath.
+- If there are issues, fix and revalidate. Do not exceed 3 iterations.
+Do not continue if this step cannot be completed successfully.
+
+### Step 3: Configure Importer
+- If requested, change the importer's settings.
+- If requested, assign the requested RuleSet to the Importer.
+- If requested, make changes to the LOD generation.
+Continue only if asked to also import the file. The import process can be very long, so NEVER assume you must import the file unless it was requested.
+
+### Step 4: Import
+- Start the asynchronous import using `ATTAssistantUtilities.ImportFile()`.
+- Report whether the import process started successfully. Remind the user this is a background process.
+
+## Importer utility functions
+
+The following functions are from `Unity.Pixyz.Plugin4Unity.Editor.AI.ATTAssistantUtilities`.
+
+### `EnsureImporterSaveFolder`
+
+Returns the project-relative asset save folder configured in Asset Transformer Toolkit Project Settings, creating it if it does not already exist. Use this as the destination path when creating a new `ImporterScriptableObject` asset.
+
+```csharp
+public static string EnsureImporterSaveFolder()
+```
+
+Returns a `string` such as `"Assets/3DModels"`.
+
+### `GetImporterTypes`
+
+Returns the names of all `ImporterScriptableObject` types available in the project, including user-defined importers. Always call this before creating or referencing an importer type — never assume a type exists.
+
+```csharp
+public static string[] GetImporterTypes()
+```
+
+Returns a `string[]` of unqualified type names (e.g. `"CADImporterScriptableObject"`).
+
+### `GetImporterProperties`
+
+Returns the public serialized fields of an `ImporterScriptableObject` type by name, including fields from intermediate base classes. Use this to discover what settings are available on any importer type — concrete importer classes may be internal or user-defined.
+
+```csharp
+public static ImporterPropertyInfo[] GetImporterProperties(string typeName)
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `typeName` | string | required | Unqualified type name as returned by `GetImporterTypes()`. |
+
+Returns an `ImporterPropertyInfo[]`. Each entry has the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `Name` | string | Human-readable property name. |
+| `Type` | string | Unqualified type name of the field. |
+| `SerializedPropertyPath` | string | The exact string to pass to `SerializedObject.FindProperty`. For auto-properties declared with `[field: SerializeField]`, this differs from `Name` (e.g. `<MyProperty>k__BackingField`). Always use this field — never construct the path from `Name` yourself. |
+
+### `CreateImporter`
+
+Creates a new `ImporterScriptableObject` asset for the given file. Call `GetImporterTypes()` first to confirm the type name — never assume or invent one. Use `EnsureImporterSaveFolder()` to get the correct save path.
+
+```csharp
+public static string CreateImporter(string filePath, string typeName, string savePath)
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `filePath` | string | required | Absolute system path to the 3D file the importer will reference. |
+| `typeName` | string | required | Unqualified importer type name as returned by `GetImporterTypes()`. |
+| `savePath` | string | required | Project-relative folder path where the importer asset will be saved. |
+
+Returns a `string` with the project-relative path to the created asset (e.g. `"Assets/3DModels/MyModel.asset"`). Pass this path to `ImportFile` to trigger import.
+
+### `CanImportFile`
+
+Checks whether the Asset Transformer Toolkit supports a file format. Call this before `ImportFile` to avoid runtime errors. Throws if no file exists at `filePath`.
+
+```csharp
+public static bool CanImportFile(string filePath)
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `filePath` | string | required | Absolute system path to the 3D file to check. |
+
+Returns `true` if the file format is supported, `false` otherwise.
+
+### `ImportFile`
+
+Triggers import or re-import using an existing `ImporterScriptableObject` asset. Requires an `ImporterScriptableObject` to already exist at `importerPath`.
+
+```csharp
+public static void ImportFile(string importerPath)
+```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `importerPath` | string | required | Project-relative path to the `ImporterScriptableObject` asset. |
+
+### Technical Notes
+- Because import is an asynchronous process, the imported files may not yet exist in the project by the time the prompt finishes execution.
+- The imported model will always be saved to the same directory that the ImporterScriptableObject lives in.
+- Importers are designed to be extended. Check which Importer types exist in the project using `ATTAssistantUtilities.GetImporterTypes()` instead of making assumptions like a point cloud file always maps to the PointCloudImporterScriptableObject.
+- Only one import should be processing at a time.
+- When creating a new ImporterScriptableObject, save it under the folder returned by `ATTAssistantUtilities.EnsureImporterSaveFolder()`. This reflects the user-configured save folder from Project Settings and defaults to `"Assets/3DModels"`.

package/skills/asset-transformer-toolkit/references/lods.md

@@ -0,0 +1,61 @@
+Choose a path depending on the task.
+
+### Path A: CADImporterScriptableObject
+Choose this path if working with an object that is or inherits from CADImporterScriptableObject.
+- Identify the types of LODs available in the project. Choose the one(s) most appropriate for your case.
+- Find the LODGenerator property in the Importer.
+- Execute the requested task.
+- Verify the number of rules present in the Generator does not exceed 7.
+
+### Path B: Scene Object
+Choose this path when asked to work with a scene asset directly.
+- Add a UnityEngine.PixyzPlugin4Unity.Components.LODGeneratorComponent script to the GameObject if one doesn't exist anywhere in the hierarchy.
+- Execute the given task.
+
+### Path C: PointCloudImporter
+Choose this path when working with a PointCloudImporterScriptableObject object.
+- The PointCloudImporter only permits enabling/disabling LOD generation and setting the number of LODs to be generated. Other actions like choosing the type of LODRule to apply is unsupported.
+- Models imported by the PointCloudImporter will not have a LODGeneratorComponent script attached to them.
+- If the task is permitted, execute it.
+
+### Path D: Other Importer
+Choose this path if working with a different importer type.
+- This is a user defined importer and not part of the base Asset Transformer Toolkit package. Precise instructions cannot be provided.
+- Attempt to perform the requested task, but do not exceed three iterations.
+- If the task cannot be performed successfully, inform the user working with this object is not currently supported by Assistant.
+
+## LOD utility functions
+
+The following functions are from `Unity.Pixyz.Plugin4Unity.Editor.AI.ATTAssistantUtilities`.
+
+### `GetLODRules`
+
+Returns all available `LODRule` implementations and their parameters. Use this before constructing or modifying a LOD configuration to discover valid types.
+
+```csharp
+public static LODRuleDescription[] GetLODRules()
+```
+
+Returns a `LODRuleDescription[]`, each containing the type name, assembly-qualified name, and parameter list.
+
+### `LODRuleDescription`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `Name` | string | Unqualified class name of the LODRule type. |
+| `QualifiedName` | string | Assembly-qualified name, suitable for `Type.GetType`. |
+| `Parameters` | `LODParameterInfo[]` | Configurable properties on this LODRule type. |
+
+### `LODParameterInfo`
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `Name` | string | Property name. |
+| `Type` | string | Property type name. |
+
+### Technical Notes
+- The user will need to refresh the Inspector to see changes applied by Assistant.
+- In an Importer's settings for LOD generation, the number of LODs set to generate does not include LOD0. There will always be one more LOD than the setting says. For example, setting the PointCloudImporter's NumberofLODs setting to 1 will result in the model having two LODs: LOD0 and LOD1.
+- While Unity supports up to 8 LODs including LOD0, the PointCloudImporter is a special case that only supports 7.
+- With the exception of models imported by the PointCloudImporter, models that were imported with LODs will have a LODGeneratorComponent script.
+- LODs have nothing to do with RuleSets and Actions. RuleSets and Actions will NOT help with any LOD-related task.

package/skills/asset-transformer-toolkit/references/rule-api.md

@@ -0,0 +1,154 @@
+## Contents
+- [Rule constructors](#rule-constructors) — `Rule()`
+- [Rule methods](#rule-methods) — `GetBlock`, `GetBlockIndex`, `RemoveBlockAt`, `RemoveBlock`, `AppendBlock`, `InsertBlock`, `IsLastBlock`
+- [Rule properties](#rule-properties) — `Name`, `IsEnabled`, `BlocksCount`, `Blocks`
+
+---
+
+## Rule constructors
+
+The Rule API reference contains the following constructors.
+
+### `Rule()`
+
+This constructor creates an empty Rule with no blocks.
+
+```csharp
+public Rule()
+```
+
+## Rule methods
+
+The Rule API reference contains the following methods.
+
+### `GetBlock`
+
+This method retrieves the `RuleBlock` at the specified index.
+
+```csharp
+public RuleBlock GetBlock(int i)
+```
+
+`GetBlock` accepts the following parameter.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `i` | int | required | Zero-based index of the block to retrieve. |
+
+This method returns the `RuleBlock` at the given index.
+
+### `GetBlockIndex`
+
+This method returns the index of the given `RuleBlock` within the Rule.
+
+```csharp
+public int GetBlockIndex(RuleBlock block)
+```
+
+`GetBlockIndex` accepts the following parameter.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `block` | RuleBlock | required | The `RuleBlock` whose index to find. |
+
+This method returns an `int` index, or `-1` if the block is not found.
+
+### `RemoveBlockAt`
+
+This method removes the `RuleBlock` at the specified index.
+
+```csharp
+public void RemoveBlockAt(int index)
+```
+
+`RemoveBlockAt` accepts the following parameter.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `index` | int | required | Zero-based index of the block to remove. |
+
+### `RemoveBlock`
+
+This method removes a specific `RuleBlock` instance from the Rule.
+
+```csharp
+public void RemoveBlock(RuleBlock block)
+```
+
+`RemoveBlock` accepts the following parameter.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `block` | RuleBlock | required | The `RuleBlock` instance to remove. |
+
+### `AppendBlock`
+
+This method adds a `RuleBlock` to the end of the Rule and sets its back-reference to this Rule.
+
+```csharp
+public void AppendBlock(RuleBlock block)
+```
+
+`AppendBlock` accepts the following parameter.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `block` | RuleBlock | required | The `RuleBlock` instance to append. |
+
+### `InsertBlock`
+
+This method inserts a `RuleBlock` at the specified index, shifting subsequent blocks down. If `index` is beyond the last position, the block is appended instead.
+
+```csharp
+public void InsertBlock(RuleBlock block, int index)
+```
+
+`InsertBlock` accepts the following parameters.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `block` | RuleBlock | required | The `RuleBlock` instance to insert. |
+| `index` | int | required | Zero-based position at which to insert the block. |
+
+## Rule properties
+
+The Rule API reference contains the following properties.
+
+### `Name`
+
+```csharp
+public string Name { get; set; }
+```
+
+The display name of the Rule. Setting this property notifies the UI.
+
+> **Note:** C# property names are case-sensitive. Use `Name` (capital N) — `name` does not exist and will not compile.
+
+```csharp
+rule.Name = "My Rule";
+string ruleName = rule.Name;
+```
+
+### `IsEnabled`
+
+```csharp
+public bool IsEnabled { get; set; }
+```
+
+Controls whether the Rule is active within its RuleSet. When `false`, the Rule is skipped during execution. Setting this property notifies the UI.
+
+### `BlocksCount`
+
+```csharp
+public int BlocksCount { get; }
+```
+
+The number of `RuleBlock` instances currently in the Rule.
+
+### `Blocks`
+
+```csharp
+public IEnumerable<RuleBlock> Blocks { get; }
+```
+
+An enumerable over all `RuleBlock` instances in the Rule, in execution order.