nccgs 1.0.0

package/.claude/skills/setup-vivox-voice-chat/references/voice-channels.md

@@ -0,0 +1,90 @@
+# Voice Channels
+
+## Channel Types
+
+| Type | Join method | Use for |
+|---|---|---|
+| Non-positional (group) | `JoinGroupChannelAsync` | Party, team, lobby, guild — all participants hear each other equally |
+| Echo | `JoinEchoChannelAsync` | Test-only — your own audio is echoed back |
+| Positional (3D) | `JoinPositionalChannelAsync` | Proximity / spatial audio driven by transform position |
+
+## Join Signatures
+
+```csharp
+Task JoinGroupChannelAsync(
+    string channelName,
+    ChatCapability chatCapability,
+    ChannelOptions channelOptions = null);
+
+Task JoinEchoChannelAsync(
+    string channelName,
+    ChatCapability chatCapability,
+    ChannelOptions channelOptions = null);
+
+Task JoinPositionalChannelAsync(
+    string channelName,
+    ChatCapability chatCapability,
+    Channel3DProperties positionalChannelProperties,
+    ChannelOptions channelOptions = null);
+```
+
+The returned `Task` completes when the *request* has been sent, not when the join is complete. The actual join fires `ChannelJoined(string channelName)`. Bind that event **before** calling the join method.
+
+## ChatCapability
+
+- `ChatCapability.TextOnly` — text-only channel (no audio at all)
+- `ChatCapability.AudioOnly` — voice-only, no text
+- `ChatCapability.TextAndAudio` — both
+
+## ChannelOptions
+
+Optional. Common use: set this channel as the active transmit target on join success. Leave `null` for default behavior (join without changing transmission mode).
+
+## Positional Channels — Channel3DProperties
+
+`Channel3DProperties` controls how distance and direction affect voice attenuation. Key fields:
+
+- `AudibleDistance` — beyond this, participant is inaudible.
+- `ConversationalDistance` — below this, participant is at full volume.
+- `AudioFadeIntensityByDistance` — falloff steepness between conversational and audible distance.
+- `AudioFadeModel` — `InverseByDistance`, `LinearByDistance`, `ExponentialByDistance`.
+
+Example call-site:
+
+```csharp
+var props = new Channel3DProperties(
+    audibleDistance: 50,
+    conversationalDistance: 5,
+    audioFadeIntensityByDistance: 1.0f,
+    audioFadeModel: AudioFadeModel.InverseByDistance);
+
+await VivoxService.Instance.JoinPositionalChannelAsync(
+    "world-proximity", ChatCapability.AudioOnly, props);
+```
+
+Drive per-frame position updates by calling `VivoxService.Instance.Set3DPosition(GameObject speakerObject, string channelName)` from a listener/speaker script (typically on the player camera and on remote player representations).
+
+For >200 participants in a positional channel, enable the enterprise-tier Large 3D channels setting; see the documentation map's positional channels page.
+
+## Leaving
+
+```csharp
+await VivoxService.Instance.LeaveChannelAsync(channelName);
+await VivoxService.Instance.LeaveAllChannelsAsync();
+```
+
+Both fire `ChannelLeft(string channelName)` for each channel exited.
+
+## Mic Permission
+
+Joining an `AudioOnly` or `TextAndAudio` channel requires microphone access.
+
+- **Android:** request `RECORD_AUDIO` at runtime with `Permission.RequestUserPermission(Permission.Microphone)` before the first audio-capable join. Merge `<uses-permission android:name="android.permission.RECORD_AUDIO"/>` if not present.
+- **iOS:** add `NSMicrophoneUsageDescription` to the Info.plist (Project Settings → Player → iOS → Microphone Usage Description).
+- **Desktop / WebGL:** the browser or OS prompts on first capture attempt; no code change required, but WebGL has additional limitations — see [troubleshooting.md](troubleshooting.md).
+
+## Muting
+
+- **Local mic mute (self):** `VivoxService.Instance.MuteInputDevice()` / `UnmuteInputDevice()` — parameterless pair that stops your audio from being sent anywhere. Read state via the `IsInputDeviceMuted` property.
+- **Mute another player locally (only you stop hearing them):** `participant.MutePlayerLocally()` / `participant.UnmutePlayerLocally()` on the `VivoxParticipant` from `ParticipantAddedToChannel`.
+- **Server-side kick / mute-all:** requires a privileged Vivox Access Token minted server-side.

package/.claude/skills/shader-graph-create-custom-node/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: shader-graph-create-custom-node
+description: "Generates custom Shader Graph nodes from HLSL code. Use when the user wants to create a new Shader Graph node or make existing HLSL code work as a reflected function node."
+required_packages:
+  com.unity.shadergraph: ">=17.5.0"
+---
+# Generating a custom Shader Graph node
+
+## Step 1: Generate an HLSL function definition
+- The function must be preceded by the preprocessor define `UNITY_EXPORT_REFLECTION`
+
+## Step 2: Decorate with Shader Graph hint tags
+- See `resources/all_hints.hlsl` for all valid hint tags and usage patterns
+- C#-style documentation tags are supported outside of `funchints` or `paramhints` blocks
+- Required function hints:
+  - `sg:ProviderKey`
+  - `sg:SearchCategory`
+  - `sg:SearchTerms`
+  - `sg:DisplayName`
+
+## Step 3: Write the code to an asset
+- Search the project for a `ShaderInclude` asset (`.hlsl`) that already contains custom Shader Graph nodes
+- If a matching asset exists, show the user its current contents and ask for confirmation before appending the new code
+- If no matching asset exists, create a new `.hlsl` asset
+- Ensure the file begins with `#include "ShaderApiReflectionSupport.hlsl"`

package/.claude/skills/shader-graph-create-custom-node/resources/all_hints.hlsl

@@ -0,0 +1,182 @@
+#include "ShaderApiReflectionSupport.hlsl"
+
+namespace Namespace
+{
+    struct CustomStruct
+    {
+        float Value;
+    };
+
+/// <funchints>
+///     <sg:ProviderKey>AllHintsUniqueStableID</sg:ProviderKey>
+///     <sg:DisplayName>All Known Hints</sg:DisplayName>
+///     <sg:ReturnDisplayName>Final Result</sg:ReturnDisplayName>
+///     <sg:SearchCategory>Hints/All</sg:SearchCategory>
+///     <sg:SearchTerms>Features, Reflected, Every, Hint</sg:SearchTerms>
+///     <sg:SearchName>All Hints Search Name</sg:SearchName>
+/// </funchints>
+/// <paramhints name="a">
+///     <sg:DisplayName>Custom Struct Value</sg:DisplayName>
+///     <sg:Default>0.5</sg:Default>
+///     <sg:External>Namespace</sg:External>
+/// </paramhints>
+/// <paramhints name="c3">
+///     <sg:DisplayName>Color 3</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Default>1,1,0</sg:Default>
+/// </paramhints>
+/// <paramhints name="c4">
+///     <sg:DisplayName>Color 4</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Default>1,1,0,1</sg:Default>
+/// </paramhints>
+/// <paramhints name="sc3">
+///     <sg:DisplayName>Static Color 3</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Static />
+///     <sg:Default>1,1,0</sg:Default>
+/// </paramhints>
+/// <paramhints name="sc4">
+///     <sg:DisplayName>Static Color 4</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Static />
+///     <sg:Default>1,1,0,1</sg:Default>
+/// </paramhints>
+/// <paramhints name="d">
+///     <sg:DisplayName>Dropdown</sg:DisplayName>
+///     <sg:Dropdown>OptionA, OptionB, OptionC</sg:Dropdown>
+///     <sg:Default>1</sg:Default>
+/// </paramhints>
+/// <paramhints name="sd">
+///     <sg:DisplayName>Dropdown</sg:DisplayName>
+///     <sg:Dropdown>OptionA, OptionB, OptionC</sg:Dropdown>
+///     <sg:Static />
+///     <sg:Default>2</sg:Default>
+/// </paramhints>
+/// <paramhints name="r">
+///     <sg:DisplayName>Range</sg:DisplayName>
+///     <sg:Range>0, 1</sg:Range>
+///     <sg:Default>0.75</sg:Default>
+/// </paramhints>
+/// <paramhints name="sr">
+///     <sg:DisplayName>Range</sg:DisplayName>
+///     <sg:Static />
+///     <sg:Range>0, 1</sg:Range>
+///     <sg:Default>0.25</sg:Default>
+/// </paramhints>
+/// <paramhints name="sb">
+///     <sg:DisplayName>Toggle</sg:DisplayName>
+///     <sg:Static />
+///     <sg:Default>1</sg:Default>
+/// </paramhints>
+/// <paramhints name="si">
+///     <sg:DisplayName>Integer</sg:DisplayName>
+///     <sg:Static />
+///     <sg:Default>5</sg:Default>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float3 AllHints(
+    inout CustomStruct a,
+    float3 c3,
+    inout float4 c4,
+    float3 sc3,
+    float4 sc4,
+    inout uint d,
+    uint sd,
+    float r,
+    float sr,
+    bool sb,
+    int si
+)
+{
+    return float3(a.Value, sr, sc4.r);
+}
+
+} // Namespace
+
+/// <funchints>
+///     <sg:ProviderKey>GoodReferables</sg:ProviderKey>
+/// </funchints>
+/// <paramhints name="UV">
+///     <UV/>
+///     <Default>UV2</Default>
+/// </paramhints>
+/// <paramhints name="alsoUV">
+///     <sg:Referable>UV</sg:Referable>
+///     <Default>UV1</Default>
+/// </paramhints>
+/// <paramhints name="Position">
+///     <Position/>
+///     <Default>AbsoluteWorld</Default>
+/// </paramhints>
+/// <paramhints name="Normal">
+///     <Normal/>
+///     <Default>World</Default>
+/// </paramhints>
+/// <paramhints name="Tangent">
+///     <Tangent/>
+///     <Default>Object</Default>
+/// </paramhints>
+/// <paramhints name="Bitangent">
+///     <Bitangent/>
+///     <Default>Tangent</Default>
+/// </paramhints>
+/// <paramhints name="ViewDirection">
+///     <ViewDirection/>
+///     <Default>Screen</Default>
+/// </paramhints>
+/// <paramhints name="VertColor">
+///     <VertexColor/>
+/// </paramhints>
+/// <paramhints name="ScreenPosition">
+///     <ScreenPosition/>
+///     <Default>Pixel</Default>
+/// </paramhints>
+/// <paramhints name="defaultValue">
+///     <Default>1,0,0</Default>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float3 ReferableGood(float2 UV,
+                                            float2 alsoUV,
+                                            float3 Position,
+                                            float3 Normal,
+                                            float3 Tangent,
+                                            float3 Bitangent,
+                                            float3 ViewDirection,
+                                            float4 VertColor,
+                                            float4 ScreenPosition,
+                                            float3 defaultValue)
+{
+    return float3(1,1,0);
+}
+
+/// <funchints>
+///     <sg:ProviderKey>PrecisionTest</sg:ProviderKey>
+///     <Precision/>
+/// </funchints>
+/// <paramhints name="a">
+///     <Dynamic/>
+/// </paramhints>
+/// <paramhints name="b">
+///     <Dynamic/>
+/// </paramhints>
+/// <paramhints name="c">
+///     <Dynamic/>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float2 PrecisionTest(float a, half b, out float c)
+{
+    c = a + b;
+    return (a,b);
+}
+
+/// <funchints>
+///     <sg:ProviderKey>LinkageExample</sg:ProviderKey>
+/// </funchints>
+/// <paramhints name="test">
+///     <Linkage>other</Linkage>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float3 LinkageExample(bool test, float other)
+{
+    if (test)
+        return float3(other, 0, 0);
+    else
+        return float3(0, other, 0);
+}

package/.claude/skills/sprint-plan/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: sprint-plan
+description: Creates a capacity-aware, dependency-ordered short-horizon plan from approved features, risks, Product Owner priority, and verification/closure work.
+allowed-tools: Read, Glob, Grep, Write, Edit, Task, AskUserQuestion
+---
+
+# Sprint Plan
+
+Read `.nccgs/project.yaml`, `.nccgs/state.md`, and the active context packet when present. Preserve Product Owner authority and unrelated work.
+
+Read mapped planning sources, priorities, feature readiness, dependencies, known defects, capacity assumptions, and release constraints. Do not invent dates or capacity. Select a coherent goal, order work by dependency and risk, include verification/closure, identify ownership and PO decisions, and expose stretch work separately. Persist in the canonical planning location and keep scope changes explicit.
+
+Return outcome, evidence, affected records, blockers or decisions, residual risk, and the exact next workflow. Do not claim DONE unless this is the `closure` skill and every configured gate passes.
+

package/.claude/skills/sprite-editor/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: sprite-editor
+description: Edits Unity sprite properties by generating C# editor scripts using ISpriteEditorDataProvider APIs. Handles sprite rectangles, borders, pivots, outlines, and slicing operations (automatic, grid, isometric). Use when working with sprite assets, sprite sheets, texture atlases, or sprite slicing.
+modes: [agent, ask]
+---
+
+# Sprite Editor
+
+Sprite metadata (rects, borders, pivots, outlines) lives inside the importer, not in a file
+you can edit — reaching it means running C# through a live Editor.
+
+**The `unity-cli` skill owns getting you there** — installing the CLI, confirming a connected
+Editor, adding the project's `com.unity.pipeline` package, telling a genuinely absent Editor
+apart from one stuck in Safe Mode, and discovering the Editor's command catalog. Follow it
+first; don't re-derive any of it here.
+
+Two things it can't know for you:
+
+- **You need `eval` in particular**, not just a reachable Editor. Confirm it appears in the
+  catalog — its presence depends on the Pipeline package version, not on the CLI.
+- **Never hand-edit a `.meta` file to change sprite metadata.** The importer owns that data
+  and the capability checks below exist to prevent corruption, so an unreachable Editor is a
+  stop, not a cue to improvise.
+
+Run C# through the connected Editor with the `eval` command. Discover its parameter shape
+from `unity command --format json` rather than assuming one — the inline form is
+`unity command eval --code '<snippet>'`, and some Pipeline versions also register
+`eval_file` for running a snippet from a file. **Check the catalog before reaching for
+`eval_file`; it is frequently absent.** `unity command` defaults to a 30 second timeout.
+
+Generates C# editor scripts to manipulate Unity sprites using ISpriteEditorDataProvider. Works with TextureImporter, PSBImporter, and custom importers.
+
+### Passing C# to `eval`
+
+`eval` compiles a **statement block, not a file**. Two consequences, both of which cause a
+compile error rather than a warning:
+
+- **No `using` directives.** The compiler reads `using UnityEngine;` as a resource-disposal
+  statement and rejects it (`CS0210`).
+- **Types must be fully qualified.** A bare `AssetDatabase` or `Volume` does not resolve
+  (`CS0246` / `CS0103`), and a bare `Object` is ambiguous with `object` (`CS0104`).
+
+Where a snippet below is written as a file — with usings, for readability, or because it is
+meant to be saved into the project — qualify the types before passing it to `eval`.
+
+## Workflow
+
+All generated scripts must follow the Safe Core Pattern in [references/templates.md](references/templates.md), which includes MANDATORY capability checks. NEVER attempt operations if capability checks fail - this prevents data corruption. After execution, verify results in Unity console and Project window.
+
+## Common Operations
+
+**Modify Name/Rect/Border/Pivot:** Update corresponding `SpriteRect` fields (see scripts/SetPivotExample.cs for pivot examples)
+- Requires: `EditSpriteName`, `EditSpriteRect`, `EditBorder`, or `EditPivot`
+
+**Add/Remove/Slice:** Create or filter `SpriteRect` array (see [references/background.md](references/background.md) for Unity 2021.2+ requirements)
+- Requires: `CreateAndDeleteSprite`
+
+**Set Outlines:** Get `ISpriteOutlineDataProvider` → Call `SetOutlines()` with GUID + Vector2 arrays
+
+## Important Notes
+
+- Do NOT use AssetPostprocessor or MenuItem patterns
+- Generate standalone snippets only — no `AssetPostprocessor`, no `MenuItem`
+- **Enum assignments:** Always use enum values and cast to numeric types. Never use raw numbers.
+  - ✅ Correct: `(int)SpriteAlignment.Center`
+  - ❌ Wrong: `1` (magic number)

package/.claude/skills/sprite-editor/references/api_reference.md

@@ -0,0 +1,151 @@
+# Unity Sprite Editor API Reference
+
+## Table of Contents
+- [Core Interface: ISpriteEditorDataProvider](#core-interface-ispriteeditordataprovider)
+  - [Properties](#properties)
+  - [Core Methods](#core-methods)
+  - [Callbacks](#callbacks)
+- [Additional Data Providers](#additional-data-providers)
+  - [ISpriteNameFileIdDataProvider](#ispritenamefileiddataprovider)
+  - [ISpriteOutlineDataProvider](#ispriteoutlinedataprovider)
+  - [ISpritePhysicsOutlineDataProvider](#ispritephysicsoutlinedataprovider)
+  - [ISpriteBoneDataProvider](#ispritebonedataprovider)
+  - [ISpriteMeshDataProvider](#ispritemeshdataprovider)
+  - [ITextureDataProvider](#itexturedataprovider)
+  - [ISecondaryTextureDataProvider](#isecondarytexturedataprovider)
+  - [ISpriteFrameEditCapability](#ispriteframeeditcapability)
+- [SpriteRect Properties](#spriterect-properties)
+- [Common Patterns](#common-patterns)
+  - [Modifying Sprite Properties](#modifying-sprite-properties)
+  - [Working with Selection](#working-with-selection)
+- [Version Considerations](#version-considerations)
+
+## Core Interface: ISpriteEditorDataProvider
+
+Main interface for editing sprite data. See [templates.md](templates.md) for the standard initialization and usage pattern.
+
+### Properties
+- `SpriteImportMode spriteImportMode` - How sprite data will be imported
+- `float pixelsPerUnit` - Pixels per unit in world space
+- `UnityObject targetObject` - Object providing the data
+
+### Core Methods
+- `SpriteRect[] GetSpriteRects()` - Returns array of SpriteRect
+- `void SetSpriteRects(SpriteRect[] spriteRects)` - Updates sprite rectangles
+- `void Apply()` - Applies changed data
+- `void InitSpriteEditorDataProvider()` - Initializes the provider
+- `T GetDataProvider<T>()` - Gets additional data providers
+- `bool HasDataProvider(Type type)` - Checks if provider type is supported
+
+### Callbacks
+- `void RegisterDataChangeCallback(Action<ISpriteEditorDataProvider> action)`
+- `void UnregisterDataChangeCallback(Action<ISpriteEditorDataProvider> action)`
+
+## Additional Data Providers
+
+### ISpriteNameFileIdDataProvider
+Maps sprite names to file IDs (required for Unity 2021.2+ when adding/removing sprites).
+
+```csharp
+var nameFileIdProvider = dataProvider.GetDataProvider<ISpriteNameFileIdDataProvider>();
+IEnumerable<SpriteNameFileIdPair> pairs = nameFileIdProvider.GetNameFileIdPairs();
+nameFileIdProvider.SetNameFileIdPairs(updatedPairs);
+```
+
+### ISpriteOutlineDataProvider
+Manages outline data for sprite tessellation.
+
+```csharp
+var outlineProvider = dataProvider.GetDataProvider<ISpriteOutlineDataProvider>();
+List<Vector2[]> outlines = outlineProvider.GetOutlines(spriteGuid);
+outlineProvider.SetOutlines(spriteGuid, newOutlines);
+float tessellation = outlineProvider.GetTessellationDetail(spriteGuid);
+outlineProvider.SetTessellationDetail(spriteGuid, 0.5f); // 0-1 range
+```
+
+### ISpritePhysicsOutlineDataProvider
+Manages physics outlines for Polygon Collider 2D.
+
+```csharp
+var physicsProvider = dataProvider.GetDataProvider<ISpritePhysicsOutlineDataProvider>();
+List<Vector2[]> physicsOutlines = physicsProvider.GetOutlines(spriteGuid);
+physicsProvider.SetOutlines(spriteGuid, newPhysicsOutlines);
+float tessellation = physicsProvider.GetTessellationDetail(spriteGuid);
+physicsProvider.SetTessellationDetail(spriteGuid, 0.5f);
+```
+
+### ISpriteBoneDataProvider
+Manages bone data for 2D animation.
+
+```csharp
+var boneProvider = dataProvider.GetDataProvider<ISpriteBoneDataProvider>();
+List<SpriteBone> bones = boneProvider.GetBones(spriteGuid);
+boneProvider.SetBones(spriteGuid, updatedBones);
+```
+
+### ISpriteMeshDataProvider
+Manages custom sprite mesh data (vertices, indices, edges).
+
+```csharp
+var meshProvider = dataProvider.GetDataProvider<ISpriteMeshDataProvider>();
+Vertex2DMetaData[] vertices = meshProvider.GetVertices(spriteGuid);
+int[] indices = meshProvider.GetIndices(spriteGuid);
+Vector2Int[] edges = meshProvider.GetEdges(spriteGuid);
+
+meshProvider.SetVertices(spriteGuid, newVertices);
+meshProvider.SetIndices(spriteGuid, newIndices);
+meshProvider.SetEdges(spriteGuid, newEdges);
+```
+
+### ITextureDataProvider
+Provides texture data for Sprite Editor.
+
+```csharp
+var textureProvider = dataProvider.GetDataProvider<ITextureDataProvider>();
+Texture2D texture = textureProvider.texture;
+Texture2D preview = textureProvider.previewTexture;
+textureProvider.GetTextureActualWidthAndHeight(out int width, out int height);
+Texture2D readable = textureProvider.GetReadableTexture2D();
+```
+
+### ISecondaryTextureDataProvider
+Manages secondary textures.
+
+```csharp
+var secondaryProvider = dataProvider.GetDataProvider<ISecondaryTextureDataProvider>();
+SecondarySpriteTexture[] textures = secondaryProvider.textures;
+secondaryProvider.textures = newTextures;
+```
+
+### ISpriteFrameEditCapability
+Controls sprite frame editing capabilities.
+
+```csharp
+var capabilityProvider = dataProvider.GetDataProvider<ISpriteFrameEditCapability>();
+EditCapability capability = capabilityProvider.GetEditCapability();
+capabilityProvider.SetEditCapability(newCapability);
+```
+
+## SpriteRect Properties
+
+Key properties that can be modified on `SpriteRect`:
+
+- `string name` - Sprite name
+- `GUID spriteID` - Unique identifier (matches sprite asset's `GetSpriteID()`)
+- `Rect rect` - Position and size in texture
+- `Vector2 pivot` - Pivot point (0-1 range, relative to rect)
+- `SpriteAlignment alignment` - Alignment preset (BottomLeft, Center, Custom, etc.)
+- `Vector4 border` - 9-slice border (left, bottom, right, top)
+
+**Note**: The `spriteID` property matches the GUID returned by calling `GetSpriteID()` on a sprite asset at runtime. This allows matching between editor-time configuration and runtime sprites.
+
+## Common Patterns
+
+See [templates.md](templates.md) for code patterns including:
+- Safe Core Pattern with capability checks
+- Modifying sprite properties
+- Working with selection
+
+## Version Considerations
+
+See [background.md](background.md#version-specific-requirements) for Unity version-specific requirements (ISpriteNameFileIdDataProvider in 2021.2+).

package/.claude/skills/sprite-editor/references/background.md

@@ -0,0 +1,112 @@
+# Sprite Editor Background Information
+
+## Table of Contents
+- [Why Use ISpriteEditorDataProvider](#why-use-ispriteeditordataprovider)
+- [Original vs Imported Image Sizes](#original-vs-imported-image-sizes)
+  - [The Critical Distinction](#the-critical-distinction)
+  - [Important Implications](#important-implications)
+  - [Critical for Slicing Operations](#critical-for-slicing-operations)
+- [Importer Compatibility](#importer-compatibility)
+  - [TextureImporter Configuration](#textureimporter-configuration)
+  - [Other Importers](#other-importers)
+  - [Data Provider Initialization](#data-provider-initialization)
+- [Version-Specific Requirements](#version-specific-requirements)
+  - [Unity 2021.2+](#unity-20212)
+  - [Unity 2021.1 and Earlier](#unity-20211-and-earlier)
+
+## Why Use ISpriteEditorDataProvider
+
+**ISpriteEditorDataProvider provides a unified interface** that works across all importer types (TextureImporter, PSBImporter, custom importers). This ensures:
+- Scripts work consistently regardless of importer type
+- Changes are properly communicated to the importer
+- Sprite metadata is handled correctly
+
+**Never access importer-specific properties directly.** Always use ISpriteEditorDataProvider for compatibility.
+
+## Original vs Imported Image Sizes
+
+### The Critical Distinction
+
+**Sprite data is always based on the original image size**, not the imported Texture2D size.
+
+**Original Image Size:**
+- The dimensions of the source image file before import
+- Example: 4096x4096 PNG file
+
+**Imported Texture2D Size:**
+- The actual texture size after import
+- Can be **smaller** due to:
+  - Platform-specific texture size limitations (e.g., mobile max 2048x2048)
+  - Texture compression settings
+  - Max texture size in import settings
+
+### Important Implications
+
+1. **All sprite data uses original coordinates:**
+   - Sprite rectangles (rect)
+   - Borders (for 9-slicing)
+   - Pivots
+   - Outline coordinates
+
+2. **Example:**
+   - Original image: 4096x4096 PNG
+   - Imported texture: 2048x2048 (due to max size setting)
+   - Sprite rect: `(0, 0, 4096, 4096)` ← Still uses original dimensions!
+
+3. **Unity handles scaling internally** when rendering sprites
+
+4. **Always work in original image coordinate space** when editing sprite data
+
+### Critical for Slicing Operations
+
+When performing slicing (automatic, grid, isometric), you **MUST ensure the texture being sliced matches the original source image size**.
+
+If the imported Texture2D is smaller than original:
+- Slicing coordinates will be incorrect
+- Sprite rectangles won't align with intended regions
+- The operation will fail
+
+**Solution:** Use `GetTextureToSlice` utility (see scripts/README.md) to ensure correct texture dimensions for slicing.
+
+## Importer Compatibility
+
+### TextureImporter Configuration
+
+For TextureImporter to support sprites:
+- `textureType` must be `TextureImporterType.Sprite`
+- `spriteImportMode` must be `SpriteImportMode.Multiple` for multiple sprites
+
+The pre-flight check automatically configures these settings.
+
+### Other Importers
+
+PSBImporter and custom importers may have different configuration requirements. Always verify ISpriteEditorDataProvider support before attempting sprite operations.
+
+### Data Provider Initialization
+
+See [templates.md](templates.md) for the standard initialization pattern. If `dataProvider` is null, the importer does not support sprite editing.
+
+## Version-Specific Requirements
+
+### Unity 2021.2+
+
+Adding or removing sprites requires additional steps:
+
+```csharp
+var nameFileIdProvider = dataProvider.GetDataProvider<ISpriteNameFileIdDataProvider>();
+if (nameFileIdProvider != null)
+{
+    // Get existing name-file ID pairs
+    var nameFileIdPairs = nameFileIdProvider.GetNameFileIdPairs();
+
+    // Update pairs when adding/removing sprites
+    // Add new pair: nameFileIdPairs.Add(new SpriteNameFileIdPair(name, fileId));
+    // Remove pair: nameFileIdPairs.RemoveAll(p => p.name == spriteName);
+
+    nameFileIdProvider.SetNameFileIdPairs(nameFileIdPairs);
+}
+```
+
+### Unity 2021.1 and Earlier
+
+ISpriteNameFileIdDataProvider does not exist. Simply use SetSpriteRects() without additional steps.