@tokens-studio/tokenscript-schemas 0.1.2 → 0.2.0

package/bundled/registry.json

@@ -1,3833 +0,0 @@
-{
-  "version": "0.0.10",
-  "types": [
-    {
-      "name": "CSS",
-      "type": "color",
-      "description": "CSS color string representation. Outputs the appropriate CSS syntax for any color space.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "value": {
-            "type": "string",
-            "description": "CSS color string (e.g., 'rgb(255 128 64)', 'oklch(0.7 0.15 180)')"
-          }
-        },
-        "required": [
-          "value"
-        ]
-      },
-      "initializers": [
-        {
-          "title": "CSS Color Initializer",
-          "keyword": "css",
-          "description": "Creates a CSS color from a string value",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// CSS Color Initializer\n// Accepts a CSS color string and returns it\n// This is primarily used for type registration; \n// the main usage is converting TO css from other color types\n//\n// Input: String (CSS color value)\n// Output: String (same value)\n\nvariable input: List = {input};\nvariable value: String = input.get(0);\n\nreturn value;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/rgb-color/0/",
-          "target": "$self",
-          "description": "Converts RGB (0-255) to CSS rgb() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// RGB to CSS Conversion\n// Converts RGB (0-255) to CSS rgb() syntax\n// CSS Color Level 4 modern syntax: rgb(r g b) or rgb(r g b / alpha)\n//\n// Input: Color.Rgb with r, g, b in 0-255 range, optional alpha (0-1)\n// Output: Color.CSS with value like \"rgb(255 128 64)\" or \"rgb(255 128 64 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable r: Number = round({input}.r);\nvariable g: Number = round({input}.g);\nvariable b: Number = round({input}.b);\n\nvariable css_value: String = \"rgb(\".concat(r.to_string()).concat(\" \").concat(g.to_string()).concat(\" \").concat(b.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-          "target": "$self",
-          "description": "Converts sRGB (0-1) to CSS color(srgb) syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// sRGB to CSS Conversion\n// Converts sRGB (0-1) to CSS color(srgb) syntax\n// CSS Color Level 4: color(srgb r g b) or color(srgb r g b / alpha)\n//\n// Input: Color.SRGB with r, g, b in 0-1 range, optional alpha (0-1)\n// Output: Color.CSS with value like \"color(srgb 1 0.5 0.25)\" or \"color(srgb 1 0.5 0.25 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100000;\nvariable r: Number = round({input}.r * precision) / precision;\nvariable g: Number = round({input}.g * precision) / precision;\nvariable b: Number = round({input}.b * precision) / precision;\n\nvariable css_value: String = \"color(srgb \".concat(r.to_string()).concat(\" \").concat(g.to_string()).concat(\" \").concat(b.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hsl-color/0/",
-          "target": "$self",
-          "description": "Converts HSL to CSS hsl() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HSL to CSS Conversion\n// Converts HSL to CSS hsl() syntax\n// CSS Color Level 4: hsl(h s l) or hsl(h s l / alpha) where s and l are percentages\n//\n// Input: Color.HSL with h (0-360), s (0-1), l (0-1), optional alpha (0-1)\n// Output: Color.CSS with value like \"hsl(120 50% 75%)\" or \"hsl(120 50% 75% / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100;\nvariable h: Number = round({input}.h * precision) / precision;\nvariable s: Number = round({input}.s * 100 * precision) / precision;\nvariable l: Number = round({input}.l * 100 * precision) / precision;\n\nvariable css_value: String = \"hsl(\".concat(h.to_string()).concat(\" \").concat(s.to_string()).concat(\"% \").concat(l.to_string()).concat(\"%\");\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hwb-color/0/",
-          "target": "$self",
-          "description": "Converts HWB to CSS hwb() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HWB to CSS Conversion\n// Converts HWB to CSS hwb() syntax\n// CSS Color Level 4: hwb(h w b) or hwb(h w b / alpha) where w and b are percentages\n//\n// Input: Color.HWB with h (0-360), w (0-1), b (0-1), optional alpha (0-1)\n// Output: Color.CSS with value like \"hwb(120 10% 20%)\" or \"hwb(120 10% 20% / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100;\nvariable h: Number = round({input}.h * precision) / precision;\nvariable w: Number = round({input}.w * 100 * precision) / precision;\nvariable b_val: Number = round({input}.b * 100 * precision) / precision;\n\nvariable css_value: String = \"hwb(\".concat(h.to_string()).concat(\" \").concat(w.to_string()).concat(\"% \").concat(b_val.to_string()).concat(\"%\");\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/lab-color/0/",
-          "target": "$self",
-          "description": "Converts CIE Lab to CSS lab() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// CIE Lab to CSS Conversion\n// Converts CIE Lab to CSS lab() syntax\n// CSS Color Level 4: lab(L a b) or lab(L a b / alpha) where L is a percentage\n//\n// Input: Color.Lab with l (0-100), a, b, optional alpha (0-1)\n// Output: Color.CSS with value like \"lab(75% 20 -30)\" or \"lab(75% 20 -30 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 10000;\nvariable l: Number = round({input}.l * precision) / precision;\nvariable a: Number = round({input}.a * precision) / precision;\nvariable b_val: Number = round({input}.b * precision) / precision;\n\nvariable css_value: String = \"lab(\".concat(l.to_string()).concat(\"% \").concat(a.to_string()).concat(\" \").concat(b_val.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/lch-color/0/",
-          "target": "$self",
-          "description": "Converts CIE LCH to CSS lch() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// CIE LCH to CSS Conversion\n// Converts CIE LCH to CSS lch() syntax\n// CSS Color Level 4: lch(L C H) or lch(L C H / alpha) where L is a percentage\n//\n// Input: Color.LCH with l (0-100), c, h (0-360), optional alpha (0-1)\n// Output: Color.CSS with value like \"lch(75% 50 180)\" or \"lch(75% 50 180 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 10000;\nvariable l: Number = round({input}.l * precision) / precision;\nvariable c: Number = round({input}.c * precision) / precision;\nvariable h: Number = round({input}.h * precision) / precision;\n\nvariable css_value: String = \"lch(\".concat(l.to_string()).concat(\"% \").concat(c.to_string()).concat(\" \").concat(h.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-          "target": "$self",
-          "description": "Converts OKLab to CSS oklab() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLab to CSS Conversion\n// Converts OKLab to CSS oklab() syntax\n// CSS Color Level 4: oklab(L a b) or oklab(L a b / alpha) where L is 0-1 decimal\n//\n// Input: Color.OKLab with l (0-1), a, b, optional alpha (0-1)\n// Output: Color.CSS with value like \"oklab(0.7 0.1 -0.05)\" or \"oklab(0.7 0.1 -0.05 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100000;\nvariable l: Number = round({input}.l * precision) / precision;\nvariable a: Number = round({input}.a * precision) / precision;\nvariable b_val: Number = round({input}.b * precision) / precision;\n\nvariable css_value: String = \"oklab(\".concat(l.to_string()).concat(\" \").concat(a.to_string()).concat(\" \").concat(b_val.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-          "target": "$self",
-          "description": "Converts OKLCH to CSS oklch() syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLCH to CSS Conversion\n// Converts OKLCH to CSS oklch() syntax\n// CSS Color Level 4: oklch(L C H) or oklch(L C H / alpha) where L is 0-1 decimal\n//\n// Input: Color.OKLCH with l (0-1), c, h (0-360), optional alpha (0-1)\n// Output: Color.CSS with value like \"oklch(0.7 0.15 180)\" or \"oklch(0.7 0.15 180 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100000;\nvariable l: Number = round({input}.l * precision) / precision;\nvariable c: Number = round({input}.c * precision) / precision;\nvariable h: Number = round({input}.h * precision) / precision;\n\nvariable css_value: String = \"oklch(\".concat(l.to_string()).concat(\" \").concat(c.to_string()).concat(\" \").concat(h.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/",
-          "target": "$self",
-          "description": "Converts Linear sRGB to CSS color(srgb-linear) syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear sRGB to CSS Conversion\n// Converts Linear sRGB to CSS color(srgb-linear) syntax\n// CSS Color Level 4: color(srgb-linear r g b)\n//\n// Input: Color.LinearSRGB with r, g, b in 0-1 range\n// Output: Color.CSS with value like \"color(srgb-linear 1 0.25 0.0625)\"\n\nvariable precision: Number = 100000;\nvariable r: Number = round({input}.r * precision) / precision;\nvariable g: Number = round({input}.g * precision) / precision;\nvariable b: Number = round({input}.b * precision) / precision;\n\nvariable output: Color.CSS;\noutput.value = \"color(srgb-linear \".concat(r.to_string()).concat(\" \").concat(g.to_string()).concat(\" \").concat(b.to_string()).concat(\")\");\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D65 to CSS color(xyz-d65) syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D65 to CSS Conversion\n// Converts XYZ-D65 to CSS color(xyz-d65) syntax\n// CSS Color Level 4: color(xyz-d65 x y z) or color(xyz-d65 x y z / alpha)\n//\n// Input: Color.XYZD65 with x, y, z tristimulus values, optional alpha (0-1)\n// Output: Color.CSS with value like \"color(xyz-d65 0.4124 0.2126 0.0193)\" or \"color(xyz-d65 0.4124 0.2126 0.0193 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100000;\nvariable x: Number = round({input}.x * precision) / precision;\nvariable y: Number = round({input}.y * precision) / precision;\nvariable z: Number = round({input}.z * precision) / precision;\n\nvariable css_value: String = \"color(xyz-d65 \".concat(x.to_string()).concat(\" \").concat(y.to_string()).concat(\" \").concat(z.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d50-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D50 to CSS color(xyz-d50) syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D50 to CSS Conversion\n// Converts XYZ-D50 to CSS color(xyz-d50) syntax\n// CSS Color Level 4: color(xyz-d50 x y z) or color(xyz-d50 x y z / alpha)\n//\n// Input: Color.XYZD50 with x, y, z tristimulus values, optional alpha (0-1)\n// Output: Color.CSS with value like \"color(xyz-d50 0.4360 0.2225 0.0139)\" or \"color(xyz-d50 0.4360 0.2225 0.0139 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100000;\nvariable x: Number = round({input}.x * precision) / precision;\nvariable y: Number = round({input}.y * precision) / precision;\nvariable z: Number = round({input}.z * precision) / precision;\n\nvariable css_value: String = \"color(xyz-d50 \".concat(x.to_string()).concat(\" \").concat(y.to_string()).concat(\" \").concat(z.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/p3-color/0/",
-          "target": "$self",
-          "description": "Converts Display-P3 to CSS color(display-p3) syntax",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Display-P3 to CSS Conversion\n// Converts Display-P3 to CSS color(display-p3) syntax\n// CSS Color Level 4: color(display-p3 r g b) or color(display-p3 r g b / alpha)\n//\n// Input: Color.P3 with r, g, b in 0-1 range, optional alpha (0-1)\n// Output: Color.CSS with value like \"color(display-p3 1 0.5 0.25)\" or \"color(display-p3 1 0.5 0.25 / 0.5)\"\n// Note: Alpha is omitted if null or 1.0 (fully opaque)\n\nvariable precision: Number = 100000;\nvariable r: Number = round({input}.r * precision) / precision;\nvariable g: Number = round({input}.g * precision) / precision;\nvariable b: Number = round({input}.b * precision) / precision;\n\nvariable css_value: String = \"color(display-p3 \".concat(r.to_string()).concat(\" \").concat(g.to_string()).concat(\" \").concat(b.to_string());\n\n// Add alpha if present, not null, and not 1.0 (per CSS convention)\nvariable alpha: Number = {input}.alpha;\nif (alpha != null) [\n  if (alpha != 1) [\n    css_value = css_value.concat(\" / \").concat(alpha.to_string());\n  ];\n];\n\ncss_value = css_value.concat(\")\");\n\nvariable output: Color.CSS;\noutput.value = css_value;\nreturn output;"
-          }
-        }
-      ],
-      "slug": "css-color"
-    },
-    {
-      "name": "Hex",
-      "type": "color",
-      "description": "A color in hex format, e.g. #ff0000",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "value": {
-            "type": "string"
-          }
-        }
-      },
-      "initializers": [
-        {
-          "title": "Hex Color Initializer",
-          "keyword": "hex",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "variable c: Color.Hex;\nc.value = {input};\nreturn c;"
-          }
-        }
-      ],
-      "conversions": [],
-      "slug": "hex-color"
-    },
-    {
-      "name": "HSL",
-      "type": "color",
-      "description": "HSL color space - Hue, Saturation, Lightness. Popular for color pickers and CSS.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees)"
-          },
-          "s": {
-            "type": "number",
-            "description": "Saturation (0-1)"
-          },
-          "l": {
-            "type": "number",
-            "description": "Lightness (0-1)"
-          }
-        },
-        "required": [
-          "h",
-          "s",
-          "l"
-        ],
-        "order": [
-          "h",
-          "s",
-          "l"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "HSL Color Initializer",
-          "keyword": "hsl",
-          "description": "Creates an HSL color from H, S, L values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HSL Color Initializer\n// Creates an HSL color from H, S, L values\n// Input: List of [h, s, l] or [h, s, l, alpha] values\n\nvariable hsl_values: List = {input};\nvariable output: Color.HSL;\n\noutput.h = hsl_values.get(0);\noutput.s = hsl_values.get(1);\noutput.l = hsl_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (hsl_values.length() > 3) [\n  output.alpha = hsl_values.get(3);\n];\n\nreturn output;"
-          }
-        },
-        {
-          "title": "HSLA Color Initializer",
-          "keyword": "hsla",
-          "description": "Creates an HSL color with alpha from H, S, L, A values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HSLA Color Initializer\n// Creates an HSL color with alpha from H, S, L, A values\n//\n// Usage: hsla(180, 0.5, 0.5, 0.8) → Color.HSL { h: 180, s: 0.5, l: 0.5, alpha: 0.8 }\n//\n// Input: List of 4 numbers [h, s, l, alpha]\n// Output: Color.HSL with alpha\n\nvariable hsl_values: List = {input};\nvariable output: Color.HSL;\n\noutput.h = hsl_values.get(0);\noutput.s = hsl_values.get(1);\noutput.l = hsl_values.get(2);\noutput.alpha = hsl_values.get(3);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-          "target": "$self",
-          "description": "Converts sRGB to HSL",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// sRGB to HSL Conversion\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js\n//\n// Algorithm:\n// 1. Find max and min of R, G, B\n// 2. L = (max + min) / 2\n// 3. If max == min, S = 0 (achromatic)\n// 4. Else S = (max - min) / (1 - |2L - 1|)\n// 5. H depends on which channel is max\n//\n// Input: Color.SRGB with r, g, b in 0-1 range\n// Output: Color.HSL with h (0-360), s (0-1), l (0-1)\n\n// Get input sRGB values\nvariable r: Number = {input}.r;\nvariable g: Number = {input}.g;\nvariable b: Number = {input}.b;\n\n// Find max and min\nvariable max_val: Number = r;\nif (g > max_val) [\n    max_val = g;\n];\nif (b > max_val) [\n    max_val = b;\n];\n\nvariable min_val: Number = r;\nif (g < min_val) [\n    min_val = g;\n];\nif (b < min_val) [\n    min_val = b;\n];\n\n// Calculate lightness\nvariable l: Number = (max_val + min_val) / 2;\n\n// Calculate saturation and hue\nvariable s: Number = 0;\nvariable h: Number = 0;\nvariable delta: Number = max_val - min_val;\n\nif (delta > 0) [\n    // Not achromatic\n    \n    // Saturation formula\n    variable abs_2l_minus_1: Number = 2 * l - 1;\n    if (abs_2l_minus_1 < 0) [\n        abs_2l_minus_1 = 0 - abs_2l_minus_1;\n    ];\n    s = delta / (1 - abs_2l_minus_1);\n    \n    // Hue calculation depends on which channel is max\n    if (max_val == r) [\n        h = ((g - b) / delta);\n        if (g < b) [\n            h = h + 6;\n        ];\n    ] else [\n        if (max_val == g) [\n            h = (b - r) / delta + 2;\n        ] else [\n            h = (r - g) / delta + 4;\n        ];\n    ];\n    \n    // Convert to degrees\n    h = h * 60;\n];\n\n// Normalize hue to 0-360\nif (h < 0) [\n    h = h + 360;\n];\n\n// Create output\nvariable output: Color.HSL;\noutput.h = h;\noutput.s = s;\noutput.l = l;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "hsl-color"
-    },
-    {
-      "name": "HSV",
-      "type": "color",
-      "description": "HSV color space - Hue, Saturation, Value. Also known as HSB (Hue, Saturation, Brightness).",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees)"
-          },
-          "s": {
-            "type": "number",
-            "description": "Saturation (0-1)"
-          },
-          "v": {
-            "type": "number",
-            "description": "Value/Brightness (0-1)"
-          }
-        },
-        "required": [
-          "h",
-          "s",
-          "v"
-        ],
-        "order": [
-          "h",
-          "s",
-          "v"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "HSV Color Initializer",
-          "keyword": "hsv",
-          "description": "Creates an HSV color from H, S, V values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HSV Color Initializer\n// Creates an HSV color from H, S, V values\n// Input: List of [h, s, v] or [h, s, v, alpha] values\n\nvariable hsv_values: List = {input};\nvariable output: Color.HSV;\n\noutput.h = hsv_values.get(0);\noutput.s = hsv_values.get(1);\noutput.v = hsv_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (hsv_values.length() > 3) [\n  output.alpha = hsv_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-          "target": "$self",
-          "description": "Converts sRGB to HSV",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// sRGB to HSV Conversion\n// Reference: Standard RGB to HSV algorithm\n//\n// Algorithm:\n// V = max(R, G, B)\n// S = (V - min(R, G, B)) / V  (if V > 0)\n// H depends on which channel is max\n//\n// Input: Color.SRGB with r, g, b in 0-1 range\n// Output: Color.HSV with h (0-360), s (0-1), v (0-1)\n\n// Get input sRGB values\nvariable r: Number = {input}.r;\nvariable g: Number = {input}.g;\nvariable b: Number = {input}.b;\n\n// Find max and min\nvariable max_val: Number = r;\nif (g > max_val) [\n    max_val = g;\n];\nif (b > max_val) [\n    max_val = b;\n];\n\nvariable min_val: Number = r;\nif (g < min_val) [\n    min_val = g;\n];\nif (b < min_val) [\n    min_val = b;\n];\n\n// Value is the max channel\nvariable v: Number = max_val;\n\n// Calculate saturation and hue\nvariable s: Number = 0;\nvariable h: Number = 0;\nvariable delta: Number = max_val - min_val;\n\nif (max_val > 0) [\n    s = delta / max_val;\n];\n\nif (delta > 0) [\n    // Hue calculation depends on which channel is max\n    if (max_val == r) [\n        h = ((g - b) / delta);\n        if (g < b) [\n            h = h + 6;\n        ];\n    ] else [\n        if (max_val == g) [\n            h = (b - r) / delta + 2;\n        ] else [\n            h = (r - g) / delta + 4;\n        ];\n    ];\n    \n    // Convert to degrees\n    h = h * 60;\n];\n\n// Normalize hue to 0-360\nif (h < 0) [\n    h = h + 360;\n];\n\n// Create output\nvariable output: Color.HSV;\noutput.h = h;\noutput.s = s;\noutput.v = v;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "hsv-color"
-    },
-    {
-      "name": "HWB",
-      "type": "color",
-      "description": "HWB color space - Hue, Whiteness, Blackness. CSS Color Level 4.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees)"
-          },
-          "w": {
-            "type": "number",
-            "description": "Whiteness (0-1)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Blackness (0-1)"
-          }
-        },
-        "required": [
-          "h",
-          "w",
-          "b"
-        ],
-        "order": [
-          "h",
-          "w",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "HWB Color Initializer",
-          "keyword": "hwb",
-          "description": "Creates an HWB color from H, W, B values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HWB Color Initializer\n// Creates an HWB color from H, W, B values\n// Input: List of [h, w, b] or [h, w, b, alpha] values\n\nvariable hwb_values: List = {input};\nvariable output: Color.HWB;\n\noutput.h = hwb_values.get(0);\noutput.w = hwb_values.get(1);\noutput.b = hwb_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (hwb_values.length() > 3) [\n  output.alpha = hwb_values.get(3);\n];\n\nreturn output;"
-          }
-        },
-        {
-          "title": "HWBA Color Initializer",
-          "keyword": "hwba",
-          "description": "Creates an HWB color with alpha from H, W, B, A values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HWBA Color Initializer\n// Creates an HWB color with alpha from H, W, B, A values\n//\n// Usage: hwba(180, 0.2, 0.3, 0.9) → Color.HWB { h: 180, w: 0.2, b: 0.3, alpha: 0.9 }\n//\n// Input: List of 4 numbers [h, w, b, alpha]\n// Output: Color.HWB with alpha\n\nvariable hwb_values: List = {input};\nvariable output: Color.HWB;\n\noutput.h = hwb_values.get(0);\noutput.w = hwb_values.get(1);\noutput.b = hwb_values.get(2);\noutput.alpha = hwb_values.get(3);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hsv-color/0/",
-          "target": "$self",
-          "description": "Converts HSV to HWB",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HSV to HWB Conversion\n// Reference: CSS Color Level 4\n//\n// Algorithm:\n// H stays the same\n// W = (1 - S) * V  (Whiteness)\n// B = 1 - V        (Blackness)\n//\n// Input: Color.HSV with h, s, v values\n// Output: Color.HWB with h, w, b values\n\n// Get input HSV values\nvariable h: Number = {input}.h;\nvariable s: Number = {input}.s;\nvariable v: Number = {input}.v;\n\n// Calculate whiteness and blackness\nvariable w: Number = (1 - s) * v;\nvariable b: Number = 1 - v;\n\n// Create output\nvariable output: Color.HWB;\noutput.h = h;\noutput.w = w;\noutput.b = b;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "hwb-color"
-    },
-    {
-      "name": "Lab",
-      "type": "color",
-      "description": "CIE Lab (L*a*b*) perceptually uniform color space. L is lightness (0-100), a is green-red axis, b is blue-yellow axis.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "l": {
-            "type": "number",
-            "description": "Lightness (0-100)"
-          },
-          "a": {
-            "type": "number",
-            "description": "Green-red axis (typically -125 to 125)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Blue-yellow axis (typically -125 to 125)"
-          }
-        },
-        "required": [
-          "l",
-          "a",
-          "b"
-        ],
-        "order": [
-          "l",
-          "a",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "Lab Color Initializer",
-          "keyword": "lab",
-          "description": "Creates a CIE Lab color from L, a, b values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// CIE Lab Color Initializer\n// Creates a Lab color from L, a, b values\n// Input: List of [l, a, b] or [l, a, b, alpha] values\n\nvariable lab_values: List = {input};\nvariable output: Color.Lab;\n\noutput.l = lab_values.get(0);\noutput.a = lab_values.get(1);\noutput.b = lab_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (lab_values.length() > 3) [\n  output.alpha = lab_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d50-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D50 to CIE Lab using the CIE standard formula",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D50 to CIE Lab Conversion\n// Reference: CIE 15.3:2004 section 8.2.1.1\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/lab.js\n//\n// Algorithm:\n// 1. Scale XYZ by D50 white point reference\n// 2. Apply f function: f(x) = x > ε ? cbrt(x) : (κ*x + 16)/116\n// 3. L = 116 * f[Y] - 16\n// 4. a = 500 * (f[X] - f[Y])\n// 5. b = 200 * (f[Y] - f[Z])\n//\n// Input: Color.XYZD50 with x, y, z tristimulus\n// Output: Color.Lab with l, a, b coordinates\n\n// Get input XYZ-D50 values\nvariable x: Number = {input}.x;\nvariable y: Number = {input}.y;\nvariable z: Number = {input}.z;\n\n// CIE constants (exact rational fractions)\n// ε = 216/24389 = (6/29)^3\nvariable epsilon: Number = 0.008856451679035631;\n// κ = 24389/27 = (29/3)^3  \nvariable kappa: Number = 903.2962962962963;\n\n// D50 white point reference (ColorJS exact values)\n// D50: [0.3457/0.3585, 1.0, (1-0.3457-0.3585)/0.3585]\nvariable white_x: Number = 0.9642956764295677;\nvariable white_y: Number = 1.0;\nvariable white_z: Number = 0.8251046025104602;\n\n// Scale XYZ by white point\nvariable xr: Number = x / white_x;\nvariable yr: Number = y / white_y;\nvariable zr: Number = z / white_z;\n\n// Apply f function with cube root\n// f(t) = t > ε ? t^(1/3) : (κt + 16) / 116\nvariable cube_root_exp: Number = 0.3333333333333333;\n\nvariable fx: Number = 0;\nvariable fy: Number = 0;\nvariable fz: Number = 0;\n\nif (xr > epsilon) [\n    fx = pow(xr, cube_root_exp);\n] else [\n    fx = (kappa * xr + 16) / 116;\n];\n\nif (yr > epsilon) [\n    fy = pow(yr, cube_root_exp);\n] else [\n    fy = (kappa * yr + 16) / 116;\n];\n\nif (zr > epsilon) [\n    fz = pow(zr, cube_root_exp);\n] else [\n    fz = (kappa * zr + 16) / 116;\n];\n\n// Calculate Lab values\nvariable lab_l: Number = 116 * fy - 16;\nvariable lab_a: Number = 500 * (fx - fy);\nvariable lab_b: Number = 200 * (fy - fz);\n\n// Create output\nvariable output: Color.Lab;\noutput.l = lab_l;\noutput.a = lab_a;\noutput.b = lab_b;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "lab-color"
-    },
-    {
-      "name": "LCH",
-      "type": "color",
-      "description": "CIE LCH color space - the polar form of CIE Lab. L is lightness (0-100), C is chroma, H is hue angle (0-360).",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "l": {
-            "type": "number",
-            "description": "Lightness (0-100)"
-          },
-          "c": {
-            "type": "number",
-            "description": "Chroma"
-          },
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees)"
-          }
-        },
-        "required": [
-          "l",
-          "c",
-          "h"
-        ],
-        "order": [
-          "l",
-          "c",
-          "h"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "LCH Color Initializer",
-          "keyword": "lch",
-          "description": "Creates a CIE LCH color from L, C, H values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// CIE LCH Color Initializer\n// Creates a LCH color from L, C, H values\n// Input: List of [l, c, h] or [l, c, h, alpha] values\n\nvariable lch_values: List = {input};\nvariable output: Color.LCH;\n\noutput.l = lch_values.get(0);\noutput.c = lch_values.get(1);\noutput.h = lch_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (lch_values.length() > 3) [\n  output.alpha = lch_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/lab-color/0/",
-          "target": "$self",
-          "description": "Converts CIE Lab to LCH using Cartesian to polar transformation",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// CIE Lab to LCH Conversion\n// Converts Cartesian (a, b) to polar (C, H) coordinates\n// Same algorithm as OKLab → OKLCH, but for CIE Lab\n//\n// Algorithm:\n// L stays the same (lightness 0-100)\n// C = sqrt(a² + b²) (chroma)\n// H = atan2(b, a) * 180/π (hue angle in degrees)\n//\n// Input: Color.Lab with l, a, b coordinates\n// Output: Color.LCH with l, c, h coordinates\n\n// Get input Lab values\nvariable l: Number = {input}.l;\nvariable a: Number = {input}.a;\nvariable b: Number = {input}.b;\n\n// Constants\nvariable pi: Number = pi();\nvariable rad_to_deg: Number = 180 / pi;\n\n// Calculate chroma (distance from neutral axis)\nvariable c: Number = sqrt(a * a + b * b);\n\n// Calculate hue angle using atan2\nvariable h_rad: Number = atan2(b, a);\nvariable h: Number = h_rad * rad_to_deg;\n\n// Normalize hue to 0-360 range\nif (h < 0) [\n    h = h + 360;\n];\n\n// Create output\nvariable output: Color.LCH;\noutput.l = l;\noutput.c = c;\noutput.h = h;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "lch-color"
-    },
-    {
-      "name": "OKHSL",
-      "type": "color",
-      "description": "OKHSL color space by Björn Ottosson - a perceptually uniform HSL based on OKLab. H is hue (0-360), S is saturation (0-1, normalized to sRGB gamut), L is lightness (0-1). Reference: https://bottosson.github.io/posts/colorpicker/",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees), same as OKLCH hue"
-          },
-          "s": {
-            "type": "number",
-            "description": "Saturation (0-1), normalized relative to sRGB gamut boundary"
-          },
-          "l": {
-            "type": "number",
-            "description": "Lightness (0-1), perceptually uniform with toe function applied"
-          }
-        },
-        "required": [
-          "h",
-          "s",
-          "l"
-        ],
-        "order": [
-          "h",
-          "s",
-          "l"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "OKHSL Color Initializer",
-          "keyword": "okhsl",
-          "description": "Creates an OKHSL color from H, S, L values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKHSL Color Initializer\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n//\n// Creates an OKHSL color from hue, saturation, and lightness values.\n// OKHSL is a perceptually uniform version of HSL built on OKLab.\n//\n// Parameters:\n// - h: Hue angle (0-360 degrees), same as OKLCH hue\n// - s: Saturation (0-1), normalized to sRGB gamut boundary\n// - l: Lightness (0-1), perceptually uniform with toe function\n// - alpha: Optional alpha channel (0-1)\n//\n// Input: Object with h, s, l, and optional alpha properties\n// Output: Color.OKHSL\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable l: Number = input.l;\n\nvariable output: Color.OKHSL;\noutput.h = h;\noutput.s = s;\noutput.l = l;\n\n// Set alpha if provided\nif (input.alpha != null) [\n  output.alpha = input.alpha;\n];\n\noutput"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-          "target": "$self",
-          "description": "Converts OKLab to OKHSL using Ottosson's algorithm with Halley's method refinement for gamut boundary",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLab to OKHSL Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsl.js\n// Reference: https://bottosson.github.io/posts/oklab/ (original OKLab paper)\n//\n// OKHSL provides a perceptually uniform HSL with proper saturation scaling.\n// The algorithm uses three key chroma values (C_0, C_mid, C_max) and\n// performs piecewise interpolation to map chroma to saturation.\n//\n// This implementation includes the FULL findGamutIntersection algorithm\n// with Halley's method refinement for accurate gamut boundary detection.\n//\n// Input: Color.OKLab with l (0-1), a, b coordinates\n// Output: Color.OKHSL with h (0-360), s (0-1), l (0-1)\n\nvariable lab_l: Number = input.l;\nvariable lab_a: Number = input.a;\nvariable lab_b: Number = input.b;\n\n// Native constants\nvariable pi_val: Number = pi();\nvariable float_max: Number = 999999999;\n\n// Toe function constants\n// K3 = (1 + K1) / (1 + K2)\nvariable toe_k1: Number = 0.206;\nvariable toe_k2: Number = 0.03;\nvariable toe_k3: Number = 1.17009708737864;\n\n// LMS to OKLab matrix coefficients (LabtoLMS_M columns 1,2)\nvariable lab_lms_kl_a: Number = 0.3963377774;\nvariable lab_lms_kl_b: Number = 0.2158037573;\nvariable lab_lms_km_a: Number = -0.1055613458;\nvariable lab_lms_km_b: Number = -0.0638541728;\nvariable lab_lms_ks_a: Number = -0.0894841775;\nvariable lab_lms_ks_b: Number = -1.2914855480;\n\n// LMS to sRGB-linear matrix\nvariable lms_r0: Number = 4.0767416360759583;\nvariable lms_r1: Number = -3.3077115392580629;\nvariable lms_r2: Number = 0.2309699031821043;\nvariable lms_g0: Number = -1.2684379732850315;\nvariable lms_g1: Number = 2.6097573492876882;\nvariable lms_g2: Number = -0.3413193760026570;\nvariable lms_b0: Number = -0.0041960761386756;\nvariable lms_b1: Number = -0.7034186179359362;\nvariable lms_b2: Number = 1.7076146940746117;\n\n// RGB limit coefficients for determining which channel clips first\nvariable red_limit_a: Number = -1.8817031;\nvariable red_limit_b: Number = -0.80936501;\nvariable green_limit_a: Number = 1.8144408;\nvariable green_limit_b: Number = -1.19445267;\n\n// Red Kn coefficients\nvariable red_k0: Number = 1.19086277;\nvariable red_k1: Number = 1.76576728;\nvariable red_k2: Number = 0.59662641;\nvariable red_k3: Number = 0.75515197;\nvariable red_k4: Number = 0.56771245;\n\n// Green Kn coefficients\nvariable green_k0: Number = 0.73956515;\nvariable green_k1: Number = -0.45954404;\nvariable green_k2: Number = 0.08285427;\nvariable green_k3: Number = 0.12541073;\nvariable green_k4: Number = -0.14503204;\n\n// Blue Kn coefficients\nvariable blue_k0: Number = 1.35733652;\nvariable blue_k1: Number = -0.00915799;\nvariable blue_k2: Number = -1.1513021;\nvariable blue_k3: Number = -0.50559606;\nvariable blue_k4: Number = 0.00692167;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Convert to polar coordinates and apply toe function\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = sqrt(lab_a * lab_a + lab_b * lab_b);\n\n// Apply toe function: toe(x) = 0.5 * (k3*x - k1 + sqrt((k3*x - k1)^2 + 4*k2*k3*x))\nvariable l: Number = lab_l;\nif (lab_l > 0.0001 && lab_l < 0.9999) [\n  variable term: Number = toe_k3 * lab_l - toe_k1;\n  l = 0.5 * (term + sqrt(term * term + 4 * toe_k2 * toe_k3 * lab_l));\n];\n\n// Compute hue using atan2(-b, -a) + 0.5 (ColorJS convention)\nvariable h: Number = 0;\nif (c > 0.00001) [\n  variable h_normalized: Number = 0.5 + atan2(-lab_b, -lab_a) / (2 * pi_val);\n  h = h_normalized * 360;\n  if (h < 0) [ h = h + 360; ];\n  if (h >= 360) [ h = h - 360; ];\n];\n\n// Initialize saturation\nvariable s: Number = 0;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Check if chromatic (non-achromatic, non-edge)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable is_chromatic: Number = 1;\nif (c < 0.00001) [ is_chromatic = 0; ];\nif (l < 0.0001) [ is_chromatic = 0; ];\nif (l > 0.9999) [ is_chromatic = 0; ];\n\nif (is_chromatic > 0.5) [\n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 3: Normalize hue direction (a_, b_)\n  // ═══════════════════════════════════════════════════════════════════════\n  variable a_: Number = lab_a / c;\n  variable b_: Number = lab_b / c;\n  \n  // Pre-compute LMS coefficients\n  variable kl: Number = lab_lms_kl_a * a_ + lab_lms_kl_b * b_;\n  variable km: Number = lab_lms_km_a * a_ + lab_lms_km_b * b_;\n  variable ks: Number = lab_lms_ks_a * a_ + lab_lms_ks_b * b_;\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 4: computeMaxSaturation - Find S_max for this hue\n  // ═══════════════════════════════════════════════════════════════════════\n  variable test_red: Number = red_limit_a * a_ + red_limit_b * b_;\n  variable test_green: Number = green_limit_a * a_ + green_limit_b * b_;\n  \n  variable k0: Number = blue_k0;\n  variable k1_coef: Number = blue_k1;\n  variable k2_coef: Number = blue_k2;\n  variable k3_coef: Number = blue_k3;\n  variable k4_coef: Number = blue_k4;\n  variable wl: Number = lms_b0;\n  variable wm: Number = lms_b1;\n  variable ws: Number = lms_b2;\n  \n  if (test_red > 1) [\n    k0 = red_k0; k1_coef = red_k1; k2_coef = red_k2; k3_coef = red_k3; k4_coef = red_k4;\n    wl = lms_r0; wm = lms_r1; ws = lms_r2;\n  ] else [\n    if (test_green > 1) [\n      k0 = green_k0; k1_coef = green_k1; k2_coef = green_k2; k3_coef = green_k3; k4_coef = green_k4;\n      wl = lms_g0; wm = lms_g1; ws = lms_g2;\n    ];\n  ];\n  \n  // Polynomial approximation\n  variable s_max: Number = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement for s_max\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable halley_denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(halley_denom) > 0.000001) [\n    s_max = s_max - f * f1 / halley_denom;\n  ];\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 5: findCusp - Get L_cusp and C_cusp\n  // ═══════════════════════════════════════════════════════════════════════\n  variable l_cusp: Number = 1;\n  variable c_cusp: Number = 0;\n  \n  if (s_max > 0) [\n    variable cusp_l_: Number = 1 + s_max * kl;\n    variable cusp_m_: Number = 1 + s_max * km;\n    variable cusp_s_: Number = 1 + s_max * ks;\n    \n    variable cusp_l: Number = cusp_l_ * cusp_l_ * cusp_l_;\n    variable cusp_m: Number = cusp_m_ * cusp_m_ * cusp_m_;\n    variable cusp_s: Number = cusp_s_ * cusp_s_ * cusp_s_;\n    \n    variable cusp_r: Number = lms_r0 * cusp_l + lms_r1 * cusp_m + lms_r2 * cusp_s;\n    variable cusp_g: Number = lms_g0 * cusp_l + lms_g1 * cusp_m + lms_g2 * cusp_s;\n    variable cusp_b: Number = lms_b0 * cusp_l + lms_b1 * cusp_m + lms_b2 * cusp_s;\n    \n    variable max_rgb: Number = cusp_r;\n    if (cusp_g > max_rgb) [ max_rgb = cusp_g; ];\n    if (cusp_b > max_rgb) [ max_rgb = cusp_b; ];\n    if (max_rgb < 0.0001) [ max_rgb = 0.0001; ];\n    \n    l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n    c_cusp = l_cusp * s_max;\n  ];\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 6: findGamutIntersection - Find C_max at current L\n  // This is the FULL algorithm with Halley's method for upper half\n  //\n  // Finds intersection of line: L = L0*(1-t) + t*L1, C = t*C1\n  // where L0=L1=lab_l and C1=1 (seeking max chroma at this L)\n  // ═══════════════════════════════════════════════════════════════════════\n  variable c_max: Number = 0;\n  \n  if (l_cusp > 0.0001 && c_cusp > 0.0001) [\n    // Parameters for gamut intersection: l1=lab_l, c1=1, l0=lab_l\n    variable l1: Number = lab_l;\n    variable c1: Number = 1;\n    variable l0: Number = lab_l;\n    \n    // Check which half: (l1 - l0) * c_cusp - (l_cusp - l0) * c1\n    // Since l1 = l0 = lab_l, this simplifies to: -(l_cusp - lab_l) * 1 = lab_l - l_cusp\n    variable half_test: Number = lab_l - l_cusp;\n    variable t_intersect: Number = 0;\n    \n    if (half_test <= 0) [\n      // Lower half (below cusp) - simple triangle intersection\n      // t = (c_cusp * l0) / (c1 * l_cusp + c_cusp * (l0 - l1))\n      // Since l0 = l1, denominator = c1 * l_cusp = l_cusp\n      variable lower_denom: Number = l_cusp;\n      if (abs(lower_denom) > 0.00001) [\n        t_intersect = (c_cusp * lab_l) / lower_denom;\n      ];\n    ] else [\n      // Upper half (above cusp) - triangle + Halley's method\n      // First: triangle intersection\n      // t = (c_cusp * (l0 - 1)) / (c1 * (l_cusp - 1) + c_cusp * (l0 - l1))\n      // Since l0 = l1 = lab_l: t = (c_cusp * (lab_l - 1)) / (l_cusp - 1)\n      variable upper_denom: Number = l_cusp - 1;\n      if (abs(upper_denom) > 0.00001) [\n        t_intersect = c_cusp * (lab_l - 1) / upper_denom;\n      ];\n      \n      // Halley's method refinement for upper half\n      // dl = l1 - l0 = 0, dc = c1 = 1\n      variable dl: Number = 0;\n      variable dc: Number = 1;\n      \n      variable ldt_: Number = dl + dc * kl;\n      variable mdt_: Number = dl + dc * km;\n      variable sdt_: Number = dl + dc * ks;\n      \n      // Compute L and C at current t\n      variable L_at_t: Number = l0 * (1 - t_intersect) + t_intersect * l1;\n      variable C_at_t: Number = t_intersect * c1;\n      \n      // LMS values at (L, C)\n      variable l_at: Number = L_at_t + C_at_t * kl;\n      variable m_at: Number = L_at_t + C_at_t * km;\n      variable s_at: Number = L_at_t + C_at_t * ks;\n      \n      variable l_lms: Number = l_at * l_at * l_at;\n      variable m_lms: Number = m_at * m_at * m_at;\n      variable s_lms: Number = s_at * s_at * s_at;\n      \n      // First derivatives\n      variable ldt: Number = 3 * ldt_ * l_at * l_at;\n      variable mdt: Number = 3 * mdt_ * m_at * m_at;\n      variable sdt: Number = 3 * sdt_ * s_at * s_at;\n      \n      // Second derivatives\n      variable ldt2: Number = 6 * ldt_ * ldt_ * l_at;\n      variable mdt2: Number = 6 * mdt_ * mdt_ * m_at;\n      variable sdt2: Number = 6 * sdt_ * sdt_ * s_at;\n      \n      // Red channel Halley step\n      variable r_val: Number = lms_r0 * l_lms + lms_r1 * m_lms + lms_r2 * s_lms - 1;\n      variable r1: Number = lms_r0 * ldt + lms_r1 * mdt + lms_r2 * sdt;\n      variable r2: Number = lms_r0 * ldt2 + lms_r1 * mdt2 + lms_r2 * sdt2;\n      variable r_denom: Number = r1 * r1 - 0.5 * r_val * r2;\n      variable ur: Number = 0;\n      variable tr: Number = float_max;\n      if (abs(r_denom) > 0.000001) [\n        ur = r1 / r_denom;\n        if (ur >= 0) [ tr = -r_val * ur; ];\n      ];\n      \n      // Green channel Halley step\n      variable g_val: Number = lms_g0 * l_lms + lms_g1 * m_lms + lms_g2 * s_lms - 1;\n      variable g1: Number = lms_g0 * ldt + lms_g1 * mdt + lms_g2 * sdt;\n      variable g2: Number = lms_g0 * ldt2 + lms_g1 * mdt2 + lms_g2 * sdt2;\n      variable g_denom: Number = g1 * g1 - 0.5 * g_val * g2;\n      variable ug: Number = 0;\n      variable tg: Number = float_max;\n      if (abs(g_denom) > 0.000001) [\n        ug = g1 / g_denom;\n        if (ug >= 0) [ tg = -g_val * ug; ];\n      ];\n      \n      // Blue channel Halley step\n      variable b_val: Number = lms_b0 * l_lms + lms_b1 * m_lms + lms_b2 * s_lms - 1;\n      variable b1: Number = lms_b0 * ldt + lms_b1 * mdt + lms_b2 * sdt;\n      variable b2: Number = lms_b0 * ldt2 + lms_b1 * mdt2 + lms_b2 * sdt2;\n      variable b_denom: Number = b1 * b1 - 0.5 * b_val * b2;\n      variable ub: Number = 0;\n      variable tb: Number = float_max;\n      if (abs(b_denom) > 0.000001) [\n        ub = b1 / b_denom;\n        if (ub >= 0) [ tb = -b_val * ub; ];\n      ];\n      \n      // Take minimum of the three corrections\n      variable t_correction: Number = tr;\n      if (tg < t_correction) [ t_correction = tg; ];\n      if (tb < t_correction) [ t_correction = tb; ];\n      if (t_correction < float_max) [\n        t_intersect = t_intersect + t_correction;\n      ];\n    ];\n    \n    // C_max = t * c1 = t (since c1 = 1)\n    c_max = t_intersect;\n    if (c_max < 0) [ c_max = 0; ];\n  ];\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 7: getStMid - Polynomial approximation for mid-saturation ST\n  // ═══════════════════════════════════════════════════════════════════════\n  variable st_mid_s: Number = 0.11516993 + 1 / (\n    7.44778970 + 4.15901240 * b_ +\n    a_ * (-2.19557347 + 1.75198401 * b_ +\n      a_ * (-2.13704948 - 10.02301043 * b_ +\n        a_ * (-4.24894561 + 5.38770819 * b_ + 4.69891013 * a_))));\n  \n  variable st_mid_t: Number = 0.11239642 + 1 / (\n    1.61320320 - 0.68124379 * b_ +\n    a_ * (0.40370612 + 0.90148123 * b_ +\n      a_ * (-0.27087943 + 0.61223990 * b_ +\n        a_ * (0.00299215 - 0.45399568 * b_ - 0.14661872 * a_))));\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 8: getCs - Compute C_0, C_mid, C_max with scale factor k\n  // ═══════════════════════════════════════════════════════════════════════\n  variable st_max_s: Number = c_cusp / (l_cusp + 0.0001);\n  variable st_max_t: Number = c_cusp / (1 - l_cusp + 0.0001);\n  \n  // Scale factor k = c_max / min(L * st_max_s, (1-L) * st_max_t)\n  variable min_st: Number = lab_l * st_max_s;\n  variable min_st_t: Number = (1 - lab_l) * st_max_t;\n  if (min_st_t < min_st) [ min_st = min_st_t; ];\n  \n  variable k_factor: Number = 1;\n  if (min_st > 0.0001 && c_max > 0.0001) [\n    k_factor = c_max / min_st;\n  ];\n  \n  // C_mid = 0.9 * k * sqrt(sqrt(1 / (1/ca^4 + 1/cb^4)))\n  variable ca: Number = lab_l * st_mid_s;\n  variable cb: Number = (1 - lab_l) * st_mid_t;\n  variable ca4: Number = ca * ca * ca * ca;\n  variable cb4: Number = cb * cb * cb * cb;\n  variable c_mid: Number = 0;\n  if (ca4 > 0.0000001 && cb4 > 0.0000001) [\n    c_mid = 0.9 * k_factor * sqrt(sqrt(1 / (1 / ca4 + 1 / cb4)));\n  ];\n  \n  // C_0 using average ST values (0.4, 0.8)\n  variable ca0: Number = lab_l * 0.4;\n  variable cb0: Number = (1 - lab_l) * 0.8;\n  variable ca0_sq: Number = ca0 * ca0;\n  variable cb0_sq: Number = cb0 * cb0;\n  variable c_0: Number = 0;\n  if (ca0_sq > 0.0000001 && cb0_sq > 0.0000001) [\n    c_0 = sqrt(1 / (1 / ca0_sq + 1 / cb0_sq));\n  ];\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Step 9: Compute saturation using piecewise interpolation\n  // ═══════════════════════════════════════════════════════════════════════\n  variable mid: Number = 0.8;\n  \n  if (c < c_mid && c_mid > 0.0001 && c_0 > 0.0001) [\n    // Below mid-point: s = t * 0.8 where t = c / (k1 + k2*c)\n    variable k1_low: Number = mid * c_0;\n    variable k2_low: Number = 1 - k1_low / c_mid;\n    variable t_low: Number = c / (k1_low + k2_low * c + 0.0001);\n    s = t_low * mid;\n  ] else [\n    if (c_mid > 0.0001 && c_0 > 0.0001 && c_max > c_mid) [\n      // Above mid-point: s = 0.8 + 0.2 * t where t = (c - c_mid) / (k1 + k2*(c - c_mid))\n      variable mid_inv: Number = 1.25;\n      variable k0_high: Number = c_mid;\n      variable k1_high: Number = 0.2 * c_mid * c_mid * mid_inv * mid_inv / c_0;\n      variable k2_high: Number = 1 - k1_high / (c_max - c_mid + 0.0001);\n      variable c_diff: Number = c - k0_high;\n      variable t_high: Number = c_diff / (k1_high + k2_high * c_diff + 0.0001);\n      s = mid + 0.2 * t_high;\n    ];\n  ];\n  \n  // Clamp saturation\n  if (s > 1) [ s = 1; ];\n  if (s < 0) [ s = 0; ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKHSL;\noutput.h = h;\noutput.s = s;\noutput.l = l;\noutput"
-          }
-        }
-      ],
-      "slug": "okhsl-color"
-    },
-    {
-      "name": "OKHSV",
-      "type": "color",
-      "description": "OKHSV color space by Björn Ottosson - a perceptually uniform HSV based on OKLab. H is hue (0-360), S is saturation (0-1), V is value (0-1). Reference: https://bottosson.github.io/posts/colorpicker/",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees), same as OKLCH hue"
-          },
-          "s": {
-            "type": "number",
-            "description": "Saturation (0-1), ratio of chroma to maximum at this value"
-          },
-          "v": {
-            "type": "number",
-            "description": "Value/brightness (0-1), with V=1 being the brightest for that saturation"
-          }
-        },
-        "required": [
-          "h",
-          "s",
-          "v"
-        ],
-        "order": [
-          "h",
-          "s",
-          "v"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "OKHSV Color Initializer",
-          "keyword": "okhsv",
-          "description": "Creates an OKHSV color from H, S, V values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKHSV Color Initializer\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n//\n// Creates an OKHSV color from hue, saturation, and value.\n// OKHSV is a perceptually uniform version of HSV built on OKLab.\n//\n// Parameters:\n// - h: Hue angle (0-360 degrees), same as OKLCH hue\n// - s: Saturation (0-1), ratio of chroma to maximum at this value\n// - v: Value/brightness (0-1), with V=1 being brightest for that saturation\n// - alpha: Optional alpha channel (0-1)\n//\n// Input: Object with h, s, v, and optional alpha properties\n// Output: Color.OKHSV\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable v: Number = input.v;\n\nvariable output: Color.OKHSV;\noutput.h = h;\noutput.s = s;\noutput.v = v;\n\n// Set alpha if provided\nif (input.alpha != null) [\n  output.alpha = input.alpha;\n];\n\noutput"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-          "target": "$self",
-          "description": "Converts OKLab to OKHSV using Ottosson's algorithm with Halley's method refinement for gamut boundary",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLab to OKHSV Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsv.js\n// Reference: https://bottosson.github.io/posts/oklab/ (original OKLab paper)\n//\n// OKHSV maps colors to a perceptually uniform HSV cylinder.\n// The algorithm finds the exact gamut boundary using compute_max_saturation\n// and positions colors relative to the cusp (maximum chroma point).\n//\n// Key difference from OKHSL:\n// - V=1 means maximum brightness (white at S=0, cusp color at S=1)\n// - More intuitive for picking saturated colors\n//\n// Input: Color.OKLab with l (0-1), a, b coordinates\n// Output: Color.OKHSV with h (0-360), s (0-1), v (0-1)\n\nvariable lab_l: Number = input.l;\nvariable lab_a: Number = input.a;\nvariable lab_b: Number = input.b;\n\n// Native constants\nvariable pi_val: Number = pi();\n\n// Toe function constants (same as OKHSL)\nvariable toe_k1: Number = 0.206;\nvariable toe_k2: Number = 0.03;\nvariable toe_k3: Number = 1.17009708737864;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Convert to polar coordinates (L, C, H)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = sqrt(lab_a * lab_a + lab_b * lab_b);\nvariable h: Number = 0;\n\nif (c > 0.00001) [\n  // Note: ColorJS uses atan2(-b, -a) and adds 0.5, we use atan2(b, a)\n  h = atan2(lab_b, lab_a) * 180 / pi_val;\n  if (h < 0) [\n    h = h + 360;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Initialize defaults and apply toe function to L for V\n// toe(x) = 0.5 * (k3*x - k1 + sqrt((k3*x - k1)^2 + 4*k2*k3*x))\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s: Number = 0;\nvariable v: Number = lab_l;\n\n// Apply toe function to get initial V\nif (lab_l > 0.0001 && lab_l < 0.9999) [\n  variable term: Number = toe_k3 * lab_l - toe_k1;\n  v = 0.5 * (term + sqrt(term * term + 4 * toe_k2 * toe_k3 * lab_l));\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 3: Compute normalized hue direction\n// ═══════════════════════════════════════════════════════════════════════════\nvariable a_: Number = 0;\nvariable b_: Number = 0;\nif (c > 0.00001) [\n  a_ = lab_a / c;\n  b_ = lab_b / c;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Pre-compute LMS coefficients (used in multiple steps)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable kl: Number = 0.3963377774 * a_ + 0.2158037573 * b_;\nvariable km: Number = -0.1055613458 * a_ - 0.0638541728 * b_;\nvariable ks: Number = -0.0894841775 * a_ - 1.2914855480 * b_;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 4: Find maximum saturation and cusp\n// Only process if we have chroma (non-achromatic) and L is valid\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s_max: Number = 0;\nvariable l_cusp: Number = 1;\nvariable c_cusp: Number = 0;\n\n// Variables for LMS intermediate calculations\nvariable l_lms: Number = 0;\nvariable m_lms: Number = 0;\nvariable s_lms: Number = 0;\n\nif (c > 0.00001 && lab_l > 0.00001 && lab_l < 0.99999) [\n  // Determine which RGB component clips first\n  variable k0: Number = 0;\n  variable k1_coef: Number = 0;\n  variable k2_coef: Number = 0;\n  variable k3_coef: Number = 0;\n  variable k4_coef: Number = 0;\n  variable wl: Number = 0;\n  variable wm: Number = 0;\n  variable ws: Number = 0;\n  \n  variable test_r: Number = -1.88170328 * a_ - 0.80936493 * b_;\n  variable test_g: Number = 1.81444104 * a_ - 1.19445276 * b_;\n  \n  if (test_r > 1) [\n    k0 = 1.19086277;\n    k1_coef = 1.76576728;\n    k2_coef = 0.59662641;\n    k3_coef = 0.75515197;\n    k4_coef = 0.56771245;\n    wl = 4.0767416621;\n    wm = -3.3077115913;\n    ws = 0.2309699292;\n  ] else [\n    if (test_g > 1) [\n      k0 = 0.73956515;\n      k1_coef = -0.45954404;\n      k2_coef = 0.08285427;\n      k3_coef = 0.12541073;\n      k4_coef = -0.14503204;\n      wl = -1.2684380046;\n      wm = 2.6097574011;\n      ws = -0.3413193965;\n    ] else [\n      k0 = 1.35733652;\n      k1_coef = -0.00915799;\n      k2_coef = -1.15130210;\n      k3_coef = -0.50559606;\n      k4_coef = 0.00692167;\n      wl = -0.0041960863;\n      wm = -0.7034186147;\n      ws = 1.7076147010;\n    ];\n  ];\n  \n  // Polynomial approximation\n  s_max = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(denom) > 0.000001) [\n    s_max = s_max - f * f1 / denom;\n  ];\n  \n  // ═══════════════════════════════════════════════════════════════════════\n  // Find cusp (L_cusp, C_cusp)\n  // ═══════════════════════════════════════════════════════════════════════\n  if (s_max > 0) [\n    variable l_cusp_temp: Number = 1 + s_max * kl;\n    variable m_cusp_temp: Number = 1 + s_max * km;\n    variable s_cusp_temp: Number = 1 + s_max * ks;\n    \n    l_lms = l_cusp_temp * l_cusp_temp * l_cusp_temp;\n    m_lms = m_cusp_temp * m_cusp_temp * m_cusp_temp;\n    s_lms = s_cusp_temp * s_cusp_temp * s_cusp_temp;\n    \n    variable r_lin: Number = 4.0767416621 * l_lms - 3.3077115913 * m_lms + 0.2309699292 * s_lms;\n    variable g_lin: Number = -1.2684380046 * l_lms + 2.6097574011 * m_lms - 0.3413193965 * s_lms;\n    variable b_lin: Number = -0.0041960863 * l_lms - 0.7034186147 * m_lms + 1.7076147010 * s_lms;\n    \n    variable max_rgb: Number = r_lin;\n    if (g_lin > max_rgb) [ max_rgb = g_lin; ];\n    if (b_lin > max_rgb) [ max_rgb = b_lin; ];\n    \n    if (max_rgb > 0) [\n      l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n      c_cusp = l_cusp * s_max;\n    ];\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 5: Compute OKHSV S and V using ColorJS algorithm\n//\n// The algorithm uses the ST coordinate system where:\n// - S_t = C/L (slope from origin)\n// - T_t = C/(1-L) (slope from white)\n//\n// Key formulas from ColorJS:\n// - t = tMax / (c + l * tMax)\n// - lv = t * l, cv = t * c\n// - Apply RGB scaling and toe compensation\n// - v = l / lv, s = ((s0 + tMax) * cv) / (tMax * s0 + tMax * k * cv)\n// ═══════════════════════════════════════════════════════════════════════════\nif (c > 0.00001 && lab_l > 0.00001 && lab_l < 0.99999 && l_cusp > 0.0001 && c_cusp > 0.0001) [\n  // Compute ST values at cusp\n  variable s_t_cusp: Number = c_cusp / l_cusp;\n  variable t_t_cusp: Number = c_cusp / (1 - l_cusp + 0.0001);\n  \n  // Fixed s0 parameter\n  variable s_0: Number = 0.5;\n  variable k_param: Number = 1 - s_0 / s_t_cusp;\n  \n  // Compute t and derived values (following ColorJS exactly)\n  variable t: Number = t_t_cusp / (c + lab_l * t_t_cusp + 0.0001);\n  variable lv: Number = t * lab_l;\n  variable cv: Number = t * c;\n  \n  // Apply inverse toe to lv for compensation\n  variable lvt: Number = lv;\n  if (lv > 0.0001 && lv < 0.9999) [\n    lvt = (lv * lv + toe_k1 * lv) / (toe_k3 * (lv + toe_k2));\n  ];\n  \n  variable cvt: Number = cv;\n  if (lv > 0.0001) [\n    cvt = cv * lvt / lv;\n  ];\n  \n  // RGB scale computation\n  variable scale_l_: Number = 1 + s_max * kl;\n  variable scale_m_: Number = 1 + s_max * km;\n  variable scale_s_: Number = 1 + s_max * ks;\n  \n  variable lms_l: Number = lvt + a_ * cvt * kl;\n  variable lms_m: Number = lvt + a_ * cvt * km;\n  variable lms_s: Number = lvt + a_ * cvt * ks;\n  \n  // Convert to linear RGB using LMS\n  variable lms_l_cubed: Number = lms_l * lms_l * lms_l;\n  variable lms_m_cubed: Number = lms_m * lms_m * lms_m;\n  variable lms_s_cubed: Number = lms_s * lms_s * lms_s;\n  \n  variable rs: Number = 4.0767416621 * lms_l_cubed - 3.3077115913 * lms_m_cubed + 0.2309699292 * lms_s_cubed;\n  variable gs: Number = -1.2684380046 * lms_l_cubed + 2.6097574011 * lms_m_cubed - 0.3413193965 * lms_s_cubed;\n  variable bs: Number = -0.0041960863 * lms_l_cubed - 0.7034186147 * lms_m_cubed + 1.7076147010 * lms_s_cubed;\n  \n  variable max_s: Number = rs;\n  if (gs > max_s) [ max_s = gs; ];\n  if (bs > max_s) [ max_s = bs; ];\n  if (max_s < 0.0001) [ max_s = 0.0001; ];\n  \n  variable scale_l: Number = pow(1 / max_s, 0.3333333333333333);\n  \n  // Scale L and C\n  variable l_scaled: Number = lab_l / scale_l;\n  variable c_scaled: Number = c / scale_l;\n  \n  // Apply toe to scaled L for compensation\n  variable l_toed: Number = l_scaled;\n  if (l_scaled > 0.0001 && l_scaled < 0.9999) [\n    variable term2: Number = toe_k3 * l_scaled - toe_k1;\n    l_toed = 0.5 * (term2 + sqrt(term2 * term2 + 4 * toe_k2 * toe_k3 * l_scaled));\n  ];\n  \n  c_scaled = c_scaled * l_toed / (l_scaled + 0.0001);\n  \n  // Compute final v and s\n  if (lv > 0.0001) [\n    v = l_toed / lv;\n    if (v > 1) [ v = 1; ];\n    if (v < 0) [ v = 0; ];\n  ];\n  \n  variable denom_s: Number = t_t_cusp * s_0 + t_t_cusp * k_param * cv;\n  if (abs(denom_s) > 0.0001) [\n    s = ((s_0 + t_t_cusp) * cv) / denom_s;\n    if (s > 1) [ s = 1; ];\n    if (s < 0) [ s = 0; ];\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKHSV;\noutput.h = h;\noutput.s = s;\noutput.v = v;\noutput"
-          }
-        }
-      ],
-      "slug": "okhsv-color"
-    },
-    {
-      "name": "OKLab",
-      "type": "color",
-      "description": "OKLab perceptually uniform color space by Björn Ottosson. L is lightness (0-1), a is green-red axis, b is blue-yellow axis.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "l": {
-            "type": "number",
-            "description": "Lightness (0-1)"
-          },
-          "a": {
-            "type": "number",
-            "description": "Green-red axis (typically -0.4 to 0.4)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Blue-yellow axis (typically -0.4 to 0.4)"
-          }
-        },
-        "required": [
-          "l",
-          "a",
-          "b"
-        ],
-        "order": [
-          "l",
-          "a",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "OKLab Color Initializer",
-          "keyword": "oklab",
-          "description": "Creates an OKLab color from L, a, b values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLab Color Initializer\n// Creates an OKLab color from L, a, b values\n// Input: List of [l, a, b] or [l, a, b, alpha] values\n\nvariable lab_values: List = {input};\nvariable output: Color.OKLab;\n\noutput.l = lab_values.get(0);\noutput.a = lab_values.get(1);\noutput.b = lab_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (lab_values.length() > 3) [\n  output.alpha = lab_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D65 to OKLab using Björn Ottosson's algorithm",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D65 to OKLab Conversion\n// Uses ColorJS-compatible matrices (recalculated for consistent D65 white)\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/oklab.js\n//\n// Algorithm:\n// 1. XYZ-D65 → LMS (M1 matrix)\n// 2. LMS → LMS' (cube root transformation)\n// 3. LMS' → OKLab (M2 matrix)\n//\n// Input: Color.XYZD65 with x, y, z tristimulus\n// Output: Color.OKLab with l, a, b coordinates\n\n// Get input XYZ-D65 values\nvariable x: Number = {input}.x;\nvariable y: Number = {input}.y;\nvariable z: Number = {input}.z;\n\n// Step 1: XYZ-D65 → LMS cone response\n// ColorJS XYZtoLMS_M matrix (recalculated for consistent reference white)\nvariable lms_l: Number = x * 0.8190224379967030 + y * 0.3619062600528904 + z * -0.1288737815209879;\nvariable lms_m: Number = x * 0.0329836539323885 + y * 0.9292868615863434 + z * 0.0361446663506424;\nvariable lms_s: Number = x * 0.0481771893596242 + y * 0.2642395317527308 + z * 0.6335478284694309;\n\n// Step 2: Apply cube root (γ = 1/3)\n// Note: Using pow with 1/3 exponent (cbrt equivalent for positive values)\nvariable cube_root_exp: Number = 0.3333333333333333;\nvariable lms_l_prime: Number = pow(lms_l, cube_root_exp);\nvariable lms_m_prime: Number = pow(lms_m, cube_root_exp);\nvariable lms_s_prime: Number = pow(lms_s, cube_root_exp);\n\n// Step 3: LMS' → OKLab\n// ColorJS LMStoLab_M matrix\nvariable oklab_l: Number = lms_l_prime * 0.2104542683093140 + lms_m_prime * 0.7936177747023054 + lms_s_prime * -0.0040720430116193;\nvariable oklab_a: Number = lms_l_prime * 1.9779985324311684 + lms_m_prime * -2.4285922420485799 + lms_s_prime * 0.4505937096174110;\nvariable oklab_b: Number = lms_l_prime * 0.0259040424655478 + lms_m_prime * 0.7827717124575296 + lms_s_prime * -0.8086757549230774;\n\n// Create output\nvariable output: Color.OKLab;\noutput.l = oklab_l;\noutput.a = oklab_a;\noutput.b = oklab_b;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-          "target": "$self",
-          "description": "Converts OKLCH to OKLab (polar to cartesian)",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLCH to OKLab Conversion\n// Converts polar (C, H) back to cartesian (a, b) coordinates\n// Reference: Björn Ottosson's OKLab specification\n//\n// Algorithm:\n// L stays the same (lightness)\n// a = C * cos(H * π/180)\n// b = C * sin(H * π/180)\n//\n// Input: Color.OKLCH with l, c, h coordinates\n// Output: Color.OKLab with l, a, b coordinates\n\n// Get input OKLCH values\nvariable l: Number = {input}.l;\nvariable c: Number = {input}.c;\nvariable h: Number = {input}.h;\n\n// Constants\nvariable pi: Number = pi();\nvariable deg_to_rad: Number = pi / 180;\n\n// Convert hue to radians\nvariable h_rad: Number = h * deg_to_rad;\n\n// Convert polar to cartesian\nvariable a: Number = c * cos(h_rad);\nvariable b: Number = c * sin(h_rad);\n\n// Create output\nvariable output: Color.OKLab;\noutput.l = l;\noutput.a = a;\noutput.b = b;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/okhsl-color/0/",
-          "target": "$self",
-          "description": "Converts OKHSL to OKLab",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKHSL to OKLab Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsl.js\n//\n// Converts OKHSL back to OKLab using:\n// 1. Inverse toe function to recover OKLab lightness\n// 2. Cusp finding to determine max chroma at this hue\n// 3. Saturation denormalization to get actual chroma\n//\n// Input: Color.OKHSL with h (0-360), s (0-1), l (0-1)\n// Output: Color.OKLab with l (0-1), a, b coordinates\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable l: Number = input.l;\n\n// Native constants\nvariable pi_val: Number = pi();\n\n// Toe function constants\nvariable toe_k1: Number = 0.206;\nvariable toe_k2: Number = 0.03;\nvariable toe_k3: Number = 1.17009708737864;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Apply inverse toe function to get OKLab lightness\n// toe_inv(x) = (x^2 + k1*x) / (k3 * (x + k2))\n// ═══════════════════════════════════════════════════════════════════════════\nvariable lab_l: Number = l;\nif (l > 0.0001 && l < 0.9999) [\n  lab_l = (l * l + toe_k1 * l) / (toe_k3 * (l + toe_k2));\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Handle achromatic case\n// ═══════════════════════════════════════════════════════════════════════════\nvariable lab_a: Number = 0;\nvariable lab_b: Number = 0;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 3: Compute hue direction\n// ═══════════════════════════════════════════════════════════════════════════\nvariable h_rad: Number = h * pi_val / 180;\nvariable a_: Number = cos(h_rad);\nvariable b_: Number = sin(h_rad);\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Pre-compute LMS coefficients (used in steps 4 and 5)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable kl: Number = 0.3963377774 * a_ + 0.2158037573 * b_;\nvariable km: Number = -0.1055613458 * a_ - 0.0638541728 * b_;\nvariable ks: Number = -0.0894841775 * a_ - 1.2914855480 * b_;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 4: Find maximum saturation at this hue (same as forward conversion)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s_max: Number = 0;\n\n// Variables for LMS intermediate calculations (reused in step 5)\nvariable l_lms: Number = 0;\nvariable m_lms: Number = 0;\nvariable s_lms: Number = 0;\n\nif (s >= 0.0001) [\n  variable k0: Number = 0;\n  variable k1_coef: Number = 0;\n  variable k2_coef: Number = 0;\n  variable k3_coef: Number = 0;\n  variable k4_coef: Number = 0;\n  variable wl: Number = 0;\n  variable wm: Number = 0;\n  variable ws: Number = 0;\n  \n  variable test_r: Number = -1.88170328 * a_ - 0.80936493 * b_;\n  variable test_g: Number = 1.81444104 * a_ - 1.19445276 * b_;\n  \n  if (test_r > 1) [\n    k0 = 1.19086277;\n    k1_coef = 1.76576728;\n    k2_coef = 0.59662641;\n    k3_coef = 0.75515197;\n    k4_coef = 0.56771245;\n    wl = 4.0767416621;\n    wm = -3.3077115913;\n    ws = 0.2309699292;\n  ] else [\n    if (test_g > 1) [\n      k0 = 0.73956515;\n      k1_coef = -0.45954404;\n      k2_coef = 0.08285427;\n      k3_coef = 0.12541073;\n      k4_coef = -0.14503204;\n      wl = -1.2684380046;\n      wm = 2.6097574011;\n      ws = -0.3413193965;\n    ] else [\n      k0 = 1.35733652;\n      k1_coef = -0.00915799;\n      k2_coef = -1.15130210;\n      k3_coef = -0.50559606;\n      k4_coef = 0.00692167;\n      wl = -0.0041960863;\n      wm = -0.7034186147;\n      ws = 1.7076147010;\n    ];\n  ];\n  \n  s_max = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(denom) > 0.000001) [\n    s_max = s_max - f * f1 / denom;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 5: Find cusp\n// ═══════════════════════════════════════════════════════════════════════════\nvariable l_cusp: Number = 1;\nvariable c_cusp: Number = 0;\n\nif (s >= 0.0001 && s_max > 0) [\n  // Recompute LMS values with refined s_max (kl, km, ks already computed)\n  variable l_cusp_temp: Number = 1 + s_max * kl;\n  variable m_cusp_temp: Number = 1 + s_max * km;\n  variable s_cusp_temp: Number = 1 + s_max * ks;\n  \n  l_lms = l_cusp_temp * l_cusp_temp * l_cusp_temp;\n  m_lms = m_cusp_temp * m_cusp_temp * m_cusp_temp;\n  s_lms = s_cusp_temp * s_cusp_temp * s_cusp_temp;\n  \n  variable r_lin: Number = 4.0767416621 * l_lms - 3.3077115913 * m_lms + 0.2309699292 * s_lms;\n  variable g_lin: Number = -1.2684380046 * l_lms + 2.6097574011 * m_lms - 0.3413193965 * s_lms;\n  variable b_lin: Number = -0.0041960863 * l_lms - 0.7034186147 * m_lms + 1.7076147010 * s_lms;\n  \n  variable max_rgb: Number = r_lin;\n  if (g_lin > max_rgb) [ max_rgb = g_lin; ];\n  if (b_lin > max_rgb) [ max_rgb = b_lin; ];\n  \n  if (max_rgb > 0) [\n    l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n    c_cusp = l_cusp * s_max;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 6: Compute chroma from saturation\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = 0;\n\nif (s >= 0.0001 && l_cusp > 0.0001 && c_cusp > 0.0001) [\n  variable s_t_cusp: Number = c_cusp / l_cusp;\n  \n  // Denormalize saturation to get chroma\n  c = s * lab_l * s_t_cusp;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 7: Convert polar to cartesian\n// ═══════════════════════════════════════════════════════════════════════════\nif (s >= 0.0001) [\n  lab_a = c * a_;\n  lab_b = c * b_;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKLab;\noutput.l = lab_l;\noutput.a = lab_a;\noutput.b = lab_b;\noutput"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/okhsv-color/0/",
-          "target": "$self",
-          "description": "Converts OKHSV to OKLab",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKHSV to OKLab Conversion\n// Reference: Björn Ottosson - \"A perceptual color picker: OKHSL and OKHSV\"\n// URL: https://bottosson.github.io/posts/colorpicker/\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/okhsv.js\n//\n// Converts OKHSV back to OKLab using:\n// 1. Cusp finding to determine gamut boundary at this hue\n// 2. V and S denormalization to get L and C\n//\n// Input: Color.OKHSV with h (0-360), s (0-1), v (0-1)\n// Output: Color.OKLab with l (0-1), a, b coordinates\n\nvariable h: Number = input.h;\nvariable s: Number = input.s;\nvariable v: Number = input.v;\n\n// Native constants\nvariable pi_val: Number = pi();\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 1: Handle edge cases\n// ═══════════════════════════════════════════════════════════════════════════\nvariable lab_l: Number = v;\nvariable lab_a: Number = 0;\nvariable lab_b: Number = 0;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 2: Compute hue direction\n// ═══════════════════════════════════════════════════════════════════════════\nvariable h_rad: Number = h * pi_val / 180;\nvariable a_: Number = cos(h_rad);\nvariable b_: Number = sin(h_rad);\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Pre-compute LMS coefficients (used in steps 3 and 4)\n// ═══════════════════════════════════════════════════════════════════════════\nvariable kl: Number = 0.3963377774 * a_ + 0.2158037573 * b_;\nvariable km: Number = -0.1055613458 * a_ - 0.0638541728 * b_;\nvariable ks: Number = -0.0894841775 * a_ - 1.2914855480 * b_;\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 3: Find maximum saturation at this hue\n// ═══════════════════════════════════════════════════════════════════════════\nvariable s_max: Number = 0;\n\n// Variables for LMS intermediate calculations (reused in step 4)\nvariable l_lms: Number = 0;\nvariable m_lms: Number = 0;\nvariable s_lms: Number = 0;\n\nif (s >= 0.0001 && v >= 0.0001) [\n  variable k0: Number = 0;\n  variable k1_coef: Number = 0;\n  variable k2_coef: Number = 0;\n  variable k3_coef: Number = 0;\n  variable k4_coef: Number = 0;\n  variable wl: Number = 0;\n  variable wm: Number = 0;\n  variable ws: Number = 0;\n  \n  variable test_r: Number = -1.88170328 * a_ - 0.80936493 * b_;\n  variable test_g: Number = 1.81444104 * a_ - 1.19445276 * b_;\n  \n  if (test_r > 1) [\n    k0 = 1.19086277;\n    k1_coef = 1.76576728;\n    k2_coef = 0.59662641;\n    k3_coef = 0.75515197;\n    k4_coef = 0.56771245;\n    wl = 4.0767416621;\n    wm = -3.3077115913;\n    ws = 0.2309699292;\n  ] else [\n    if (test_g > 1) [\n      k0 = 0.73956515;\n      k1_coef = -0.45954404;\n      k2_coef = 0.08285427;\n      k3_coef = 0.12541073;\n      k4_coef = -0.14503204;\n      wl = -1.2684380046;\n      wm = 2.6097574011;\n      ws = -0.3413193965;\n    ] else [\n      k0 = 1.35733652;\n      k1_coef = -0.00915799;\n      k2_coef = -1.15130210;\n      k3_coef = -0.50559606;\n      k4_coef = 0.00692167;\n      wl = -0.0041960863;\n      wm = -0.7034186147;\n      ws = 1.7076147010;\n    ];\n  ];\n  \n  s_max = k0 + k1_coef * a_ + k2_coef * b_ + k3_coef * a_ * a_ + k4_coef * a_ * b_;\n  \n  // Halley's method refinement\n  variable l_temp: Number = 1 + s_max * kl;\n  variable m_temp: Number = 1 + s_max * km;\n  variable s_temp: Number = 1 + s_max * ks;\n  \n  variable l_cubed: Number = l_temp * l_temp * l_temp;\n  variable m_cubed: Number = m_temp * m_temp * m_temp;\n  variable s_cubed: Number = s_temp * s_temp * s_temp;\n  \n  variable l_ds: Number = 3 * kl * l_temp * l_temp;\n  variable m_ds: Number = 3 * km * m_temp * m_temp;\n  variable s_ds: Number = 3 * ks * s_temp * s_temp;\n  \n  variable l_ds2: Number = 6 * kl * kl * l_temp;\n  variable m_ds2: Number = 6 * km * km * m_temp;\n  variable s_ds2: Number = 6 * ks * ks * s_temp;\n  \n  variable f: Number = wl * l_cubed + wm * m_cubed + ws * s_cubed;\n  variable f1: Number = wl * l_ds + wm * m_ds + ws * s_ds;\n  variable f2: Number = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;\n  \n  variable denom: Number = f1 * f1 - 0.5 * f * f2;\n  if (abs(denom) > 0.000001) [\n    s_max = s_max - f * f1 / denom;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 4: Find cusp\n// ═══════════════════════════════════════════════════════════════════════════\nvariable l_cusp: Number = 1;\nvariable c_cusp: Number = 0;\n\nif (s >= 0.0001 && v >= 0.0001 && s_max > 0) [\n  // Recompute LMS values with refined s_max (kl, km, ks already computed)\n  variable l_cusp_temp: Number = 1 + s_max * kl;\n  variable m_cusp_temp: Number = 1 + s_max * km;\n  variable s_cusp_temp: Number = 1 + s_max * ks;\n  \n  l_lms = l_cusp_temp * l_cusp_temp * l_cusp_temp;\n  m_lms = m_cusp_temp * m_cusp_temp * m_cusp_temp;\n  s_lms = s_cusp_temp * s_cusp_temp * s_cusp_temp;\n  \n  variable r_lin: Number = 4.0767416621 * l_lms - 3.3077115913 * m_lms + 0.2309699292 * s_lms;\n  variable g_lin: Number = -1.2684380046 * l_lms + 2.6097574011 * m_lms - 0.3413193965 * s_lms;\n  variable b_lin: Number = -0.0041960863 * l_lms - 0.7034186147 * m_lms + 1.7076147010 * s_lms;\n  \n  variable max_rgb: Number = r_lin;\n  if (g_lin > max_rgb) [ max_rgb = g_lin; ];\n  if (b_lin > max_rgb) [ max_rgb = b_lin; ];\n  \n  if (max_rgb > 0) [\n    l_cusp = pow(1 / max_rgb, 0.3333333333333333);\n    c_cusp = l_cusp * s_max;\n  ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 5: Compute L and C from V and S\n// ═══════════════════════════════════════════════════════════════════════════\nvariable c: Number = 0;\n\nif (s >= 0.0001 && v >= 0.0001 && l_cusp > 0.0001 && c_cusp > 0.0001) [\n  variable s_t_cusp: Number = c_cusp / l_cusp;\n  variable t_t_cusp: Number = c_cusp / (1 - l_cusp + 0.0001);\n  \n  // Compute max chroma at this V\n  variable c_max_at_v: Number = 0;\n  \n  if (v <= l_cusp) [\n    c_max_at_v = v * s_t_cusp;\n  ] else [\n    c_max_at_v = (1 - v) * t_t_cusp;\n  ];\n  \n  // Compute actual chroma\n  c = s * c_max_at_v;\n  \n  // Compute L from V and C\n  // Reverse of: V = L + C / s_t_cusp\n  lab_l = v - c / (s_t_cusp + 0.0001);\n  if (lab_l < 0) [ lab_l = 0; ];\n  if (lab_l > 1) [ lab_l = 1; ];\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Step 6: Convert polar to cartesian\n// ═══════════════════════════════════════════════════════════════════════════\nif (s >= 0.0001 && v >= 0.0001) [\n  lab_a = c * a_;\n  lab_b = c * b_;\n];\n\n// ═══════════════════════════════════════════════════════════════════════════\n// Output\n// ═══════════════════════════════════════════════════════════════════════════\nvariable output: Color.OKLab;\noutput.l = lab_l;\noutput.a = lab_a;\noutput.b = lab_b;\noutput"
-          }
-        }
-      ],
-      "slug": "oklab-color"
-    },
-    {
-      "name": "OKLCH",
-      "type": "color",
-      "description": "OKLCH color space - the polar form of OKLab. L is lightness (0-1), C is chroma, H is hue angle (0-360).",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "l": {
-            "type": "number",
-            "description": "Lightness (0-1)"
-          },
-          "c": {
-            "type": "number",
-            "description": "Chroma (0 to ~0.4 for sRGB gamut)"
-          },
-          "h": {
-            "type": "number",
-            "description": "Hue angle (0-360 degrees)"
-          }
-        },
-        "required": [
-          "l",
-          "c",
-          "h"
-        ],
-        "order": [
-          "l",
-          "c",
-          "h"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "OKLCH Color Initializer",
-          "keyword": "oklch",
-          "description": "Creates an OKLCH color from L, C, H values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLCH Color Initializer\n// Creates an OKLCH color from L, C, H values\n// Input: List of [l, c, h] or [l, c, h, alpha] values\n\nvariable lch_values: List = {input};\nvariable output: Color.OKLCH;\n\noutput.l = lch_values.get(0);\noutput.c = lch_values.get(1);\noutput.h = lch_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (lch_values.length() > 3) [\n  output.alpha = lch_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-          "target": "$self",
-          "description": "Converts OKLab to OKLCH using Cartesian to polar transformation",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLab to OKLCH Conversion\n// Converts Cartesian (a, b) to polar (C, H) coordinates\n// Reference: Björn Ottosson's OKLab specification\n//\n// Algorithm:\n// L stays the same (lightness)\n// C = sqrt(a² + b²) (chroma - distance from neutral axis)\n// H = atan2(b, a) * 180/π (hue angle in degrees)\n//\n// Input: Color.OKLab with l, a, b coordinates\n// Output: Color.OKLCH with l, c, h coordinates\n\n// Get input OKLab values\nvariable l: Number = {input}.l;\nvariable a: Number = {input}.a;\nvariable b: Number = {input}.b;\n\n// Constants\nvariable pi: Number = pi();\nvariable rad_to_deg: Number = 180 / pi;\n\n// Calculate chroma (distance from neutral axis)\nvariable c: Number = sqrt(a * a + b * b);\n\n// Calculate hue angle using atan2\n// atan2(y, x) returns angle in radians from -π to π\nvariable h_rad: Number = atan2(b, a);\nvariable h: Number = h_rad * rad_to_deg;\n\n// Normalize hue to 0-360 range\nif (h < 0) [\n    h = h + 360;\n];\n\n// Create output\nvariable output: Color.OKLCH;\noutput.l = l;\noutput.c = c;\noutput.h = h;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "oklch-color"
-    },
-    {
-      "name": "P3",
-      "type": "color",
-      "description": "Display-P3 color space with sRGB transfer function. Wider gamut than sRGB, common on modern Apple displays.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "r": {
-            "type": "number",
-            "description": "Red channel (0-1, can exceed for out-of-gamut)"
-          },
-          "g": {
-            "type": "number",
-            "description": "Green channel (0-1, can exceed for out-of-gamut)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Blue channel (0-1, can exceed for out-of-gamut)"
-          }
-        },
-        "required": [
-          "r",
-          "g",
-          "b"
-        ],
-        "order": [
-          "r",
-          "g",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "Display-P3 Color Initializer",
-          "keyword": "p3",
-          "description": "Creates a Display-P3 color from 0-1 values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Display-P3 Color Initializer\n// Creates a Display-P3 color from 0-1 values\n// Input: List of [r, g, b] or [r, g, b, alpha] values\n\nvariable color_values: List = {input};\nvariable output: Color.P3;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (color_values.length() > 3) [\n  output.alpha = color_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/p3-linear-color/0/",
-          "target": "$self",
-          "description": "Converts Linear P3 to P3 by applying sRGB transfer function",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear P3 to P3 Conversion\n// Applies sRGB transfer function (gamma encoding)\n// P3 uses the same transfer function as sRGB\n// Reference: CSS Color Level 4\n//\n// Algorithm (same as sRGB):\n//   if linear ≤ 0.0031308: encoded = 12.92 × linear\n//   else: encoded = 1.055 × linear^(1/2.4) - 0.055\n//\n// Input: Color.LinearP3 with linear r, g, b values\n// Output: Color.P3 with gamma-encoded r, g, b values\n\n// Transfer function constants (same as sRGB)\nvariable threshold: Number = 0.0031308;\nvariable linear_scale: Number = 12.92;\nvariable gamma_scale: Number = 1.055;\nvariable gamma_offset: Number = 0.055;\nvariable gamma_exponent: Number = 0.4166666666666667;\n\n// Get linear values\nvariable linear_r: Number = {input}.r;\nvariable linear_g: Number = {input}.g;\nvariable linear_b: Number = {input}.b;\n\n// Convert red channel\nvariable encoded_r: Number = 0;\nif (linear_r <= threshold) [\n    encoded_r = linear_scale * linear_r;\n] else [\n    encoded_r = gamma_scale * pow(linear_r, gamma_exponent) - gamma_offset;\n];\n\n// Convert green channel\nvariable encoded_g: Number = 0;\nif (linear_g <= threshold) [\n    encoded_g = linear_scale * linear_g;\n] else [\n    encoded_g = gamma_scale * pow(linear_g, gamma_exponent) - gamma_offset;\n];\n\n// Convert blue channel\nvariable encoded_b: Number = 0;\nif (linear_b <= threshold) [\n    encoded_b = linear_scale * linear_b;\n] else [\n    encoded_b = gamma_scale * pow(linear_b, gamma_exponent) - gamma_offset;\n];\n\n// Create output\nvariable output: Color.P3;\noutput.r = encoded_r;\noutput.g = encoded_g;\noutput.b = encoded_b;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "p3-color"
-    },
-    {
-      "name": "LinearP3",
-      "type": "color",
-      "description": "Linear Display-P3 color space (gamma-decoded). Used for matrix transformations to XYZ.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "r": {
-            "type": "number",
-            "description": "Linear red channel (0-1, can exceed for HDR)"
-          },
-          "g": {
-            "type": "number",
-            "description": "Linear green channel (0-1, can exceed for HDR)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Linear blue channel (0-1, can exceed for HDR)"
-          }
-        },
-        "required": [
-          "r",
-          "g",
-          "b"
-        ],
-        "order": [
-          "r",
-          "g",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "Linear P3 Color Initializer",
-          "keyword": "linearp3",
-          "description": "Creates a linear Display-P3 color from linear 0-1 values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear P3 Color Initializer\n// Creates a linear Display-P3 color from linear 0-1 values\n// Input: List of [r, g, b] linear values\n\nvariable color_values: List = {input};\nvariable output: Color.LinearP3;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D65 to Linear P3 using the P3 transformation matrix",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D65 to Linear P3 Conversion\n// Converts CIE XYZ (D65) to linear Display-P3 RGB\n// Reference: CSS Color Level 4 specification\n//\n// Uses the inverse of the P3 to XYZ-D65 matrix\n// Matrix values from ColorJS / CSS Color Level 4\n//\n// Input: Color.XYZD65 with x, y, z tristimulus values\n// Output: Color.LinearP3 with linear r, g, b values (may be outside 0-1 for out-of-gamut)\n\n// Get XYZ values\nvariable x: Number = {input}.x;\nvariable y: Number = {input}.y;\nvariable z: Number = {input}.z;\n\n// XYZ to Linear P3 matrix (inverse of P3 to XYZ)\n// Row 1\nvariable m00: Number = 2.4934969119414254;\nvariable m01: Number = -0.9313836179191239;\nvariable m02: Number = -0.40271078445071684;\n\n// Row 2\nvariable m10: Number = -0.8294889695615747;\nvariable m11: Number = 1.7626640603183463;\nvariable m12: Number = 0.023624685841943577;\n\n// Row 3\nvariable m20: Number = 0.03584583024378447;\nvariable m21: Number = -0.07617238926804182;\nvariable m22: Number = 0.9568845240076872;\n\n// Matrix multiplication: [r, g, b] = M × [x, y, z]\nvariable linear_r: Number = m00 * x + m01 * y + m02 * z;\nvariable linear_g: Number = m10 * x + m11 * y + m12 * z;\nvariable linear_b: Number = m20 * x + m21 * y + m22 * z;\n\n// Create output (note: values may be outside 0-1 for out-of-gamut colors)\nvariable output: Color.LinearP3;\noutput.r = linear_r;\noutput.g = linear_g;\noutput.b = linear_b;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "p3-linear-color"
-    },
-    {
-      "name": "Rgb",
-      "type": "color",
-      "description": "RGB color",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "r": {
-            "type": "number"
-          },
-          "g": {
-            "type": "number"
-          },
-          "b": {
-            "type": "number"
-          }
-        },
-        "required": [
-          "r",
-          "g",
-          "b"
-        ],
-        "order": [
-          "r",
-          "g",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "function",
-          "keyword": "rgb",
-          "description": "Creates an RGB color",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// RGB Color Initializer\n// Creates an RGB color from r, g, b values (0-255 range)\n//\n// Usage: rgb(255, 128, 64) → Color.Rgb { r: 255, g: 128, b: 64 }\n//        rgb(255, 128, 64, 0.5) → Color.Rgb { r: 255, g: 128, b: 64, alpha: 0.5 }\n//\n// Input: List of 3 or 4 numbers [r, g, b] or [r, g, b, alpha]\n// Output: Color.Rgb\n\nvariable color_parts: List = {input}; \n\nvariable output: Color.Rgb;\noutput.r = color_parts.get(0);\noutput.g = color_parts.get(1);\noutput.b = color_parts.get(2);\n\n// Set alpha if provided as 4th parameter\nif (color_parts.length() > 3) [\n  output.alpha = color_parts.get(3);\n];\n\nreturn output;"
-          }
-        },
-        {
-          "title": "function",
-          "keyword": "rgba",
-          "description": "Creates an RGB color with alpha",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// RGBA Color Initializer\n// Creates an RGB color with alpha from r, g, b, a values\n//\n// Usage: rgba(255, 128, 64, 0.5) → Color.Rgb { r: 255, g: 128, b: 64, alpha: 0.5 }\n//\n// Input: List of 4 numbers [r, g, b, alpha]\n// Output: Color.Rgb with alpha\n\nvariable color_parts: List = {input}; \n\nvariable output: Color.Rgb;\noutput.r = color_parts.get(0);\noutput.g = color_parts.get(1);\noutput.b = color_parts.get(2);\noutput.alpha = color_parts.get(3);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hex-color/0/",
-          "target": "$self",
-          "description": "Converts HEX to RGB",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Hex to RGB Conversion\n// Converts hexadecimal color string to RGB (0-255 range)\n//\n// Supports both shorthand (#RGB) and standard (#RRGGBB) formats:\n//   #f00     → RGB(255, 0, 0)\n//   #ff0000  → RGB(255, 0, 0)\n//\n// Algorithm:\n// 1. Remove '#' prefix and split into characters\n// 2. For shorthand: duplicate each digit (f → ff)\n// 3. Parse hex pairs to decimal values\n//\n// Input: Color.Hex (e.g., #ff5733)\n// Output: Color.Rgb with r, g, b in 0-255 range\n\n// Split hex string on '#' and get the color value\nvariable color_parts: List = {input}.to_string().split('#'); \nvariable color: List = color_parts.get(1).split(); \nvariable length: Number = color.length(); \n\n// Initialize RGB values\nvariable rgb: List = 0, 0, 0; \n\n// Handle shorthand (#RGB) vs standard (#RRGGBB) format\nif(length == 3) [ \n  // Shorthand: duplicate each digit\n  rgb.update(0, parse_int(color.get(0).concat(color.get(0)), 16)); \n  rgb.update(1, parse_int(color.get(1).concat(color.get(1)), 16)); \n  rgb.update(2, parse_int(color.get(2).concat(color.get(2)), 16)); \n] else [ \n  // Standard: pair adjacent digits\n  rgb.update(0, parse_int(color.get(0).concat(color.get(1)), 16)); \n  rgb.update(1, parse_int(color.get(2).concat(color.get(3)), 16)); \n  rgb.update(2, parse_int(color.get(4).concat(color.get(5)), 16)); \n]; \n\n// Create output color\nvariable output: Color.Rgb; \noutput.r = rgb.get(0); \noutput.g = rgb.get(1); \noutput.b = rgb.get(2); \n\nreturn output;"
-          }
-        },
-        {
-          "source": "$self",
-          "target": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hex-color/0/",
-          "description": "Converts RGB to HEX",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// RGB to Hex Conversion\n// Converts RGB (0-255) color to hexadecimal string format\n//\n// Examples:\n//   RGB(255, 0, 0)   → #ff0000\n//   RGB(0, 255, 128) → #00ff80\n//\n// Algorithm:\n// 1. Round each channel to nearest integer\n// 2. Convert to base-16 string\n// 3. Pad single digits with leading zero\n// 4. Concatenate with '#' prefix\n//\n// Input: Color.Rgb with r, g, b in 0-255 range\n// Output: String (hex format #rrggbb)\n\nvariable rgba: List = {input}.r, {input}.g, {input}.b;\nvariable hex: String = \"#\";\nvariable i: Number = 0;\nvariable value: Number = 0;\n\n// Convert each RGB channel to hex\nwhile( i < min(rgba.length(), 3)) [\n  value = round(rgba.get(i));\n  if(value < 16) [\n    hex = hex.concat(\"0\").concat(value.to_string(16));\n  ] else [\n    hex = hex.concat(value.to_string(16));\n  ];\n  i = i + 1;\n];\n\nif (rgba.length() == 4) [\n  value = rgba.get(3) * 255; // Convert alpha to 0-255 range\n  if(value < 16) [\n    hex = hex.concat(\"0\").concat(value.to_string(16));\n  ] else [\n    hex = hex.concat(value.to_string(16));\n  ];\n];\n\nreturn hex;"
-          }
-        }
-      ],
-      "slug": "rgb-color"
-    },
-    {
-      "name": "SRGB",
-      "type": "color",
-      "description": "sRGB color space with normalized 0-1 range. The standard color space for web and displays.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "r": {
-            "type": "number",
-            "description": "Red channel (0-1)"
-          },
-          "g": {
-            "type": "number",
-            "description": "Green channel (0-1)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Blue channel (0-1)"
-          }
-        },
-        "required": [
-          "r",
-          "g",
-          "b"
-        ],
-        "order": [
-          "r",
-          "g",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "sRGB Color Initializer",
-          "keyword": "srgb",
-          "description": "Creates an sRGB color from normalized 0-1 values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// sRGB Color Initializer\n// Creates an sRGB color from normalized 0-1 values\n// Input: List of [r, g, b] or [r, g, b, alpha] values in 0-1 range\n\nvariable color_values: List = {input};\nvariable output: Color.SRGB;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\n// Set alpha if provided as 4th parameter\nif (color_values.length() > 3) [\n  output.alpha = color_values.get(3);\n];\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/rgb-color/0/",
-          "target": "$self",
-          "description": "Converts RGB (0-255) to sRGB (0-1) by normalizing",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// RGB to sRGB Conversion\n// Converts RGB (0-255) to sRGB (0-1) by normalizing\n// Input: Color.Rgb with r, g, b in 0-255 range\n// Output: Color.SRGB with r, g, b in 0-1 range\n// Lossless: Yes (simple division)\n\nvariable r_normalized: Number = {input}.r / 255;\nvariable g_normalized: Number = {input}.g / 255;\nvariable b_normalized: Number = {input}.b / 255;\n\nvariable output: Color.SRGB;\noutput.r = r_normalized;\noutput.g = g_normalized;\noutput.b = b_normalized;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/hsl-color/0/",
-          "target": "$self",
-          "description": "Converts HSL to sRGB",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// HSL to sRGB Conversion\n// Reference: https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js\n//\n// Algorithm:\n// 1. If saturation is 0, it's achromatic: R=G=B=L\n// 2. Otherwise use the HSL to RGB formula:\n//    - Calculate intermediate values based on L\n//    - Use hue to determine RGB components\n//\n// Input: Color.HSL with h (0-360), s (0-1), l (0-1)\n// Output: Color.SRGB with r, g, b in 0-1 range\n\n// Get input HSL values\nvariable h: Number = {input}.h;\nvariable s: Number = {input}.s;\nvariable l: Number = {input}.l;\n\n// Normalize hue to 0-1 range\nvariable hue: Number = h / 360;\n\n// Output values\nvariable r: Number = l;\nvariable g: Number = l;\nvariable b: Number = l;\n\n// Only calculate if there's saturation (not achromatic)\nif (s > 0) [\n    // Calculate intermediate value\n    variable q: Number = 0;\n    if (l < 0.5) [\n        q = l * (1 + s);\n    ] else [\n        q = l + s - l * s;\n    ];\n    \n    variable p: Number = 2 * l - q;\n    \n    // Helper function logic inlined for R (hue + 1/3)\n    variable tr: Number = hue + 0.333333333333333;\n    if (tr < 0) [ tr = tr + 1; ];\n    if (tr > 1) [ tr = tr - 1; ];\n    \n    if (tr < 0.166666666666667) [\n        r = p + (q - p) * 6 * tr;\n    ] else [\n        if (tr < 0.5) [\n            r = q;\n        ] else [\n            if (tr < 0.666666666666667) [\n                r = p + (q - p) * (0.666666666666667 - tr) * 6;\n            ] else [\n                r = p;\n            ];\n        ];\n    ];\n    \n    // Helper function logic inlined for G (hue)\n    variable tg: Number = hue;\n    if (tg < 0) [ tg = tg + 1; ];\n    if (tg > 1) [ tg = tg - 1; ];\n    \n    if (tg < 0.166666666666667) [\n        g = p + (q - p) * 6 * tg;\n    ] else [\n        if (tg < 0.5) [\n            g = q;\n        ] else [\n            if (tg < 0.666666666666667) [\n                g = p + (q - p) * (0.666666666666667 - tg) * 6;\n            ] else [\n                g = p;\n            ];\n        ];\n    ];\n    \n    // Helper function logic inlined for B (hue - 1/3)\n    variable tb: Number = hue - 0.333333333333333;\n    if (tb < 0) [ tb = tb + 1; ];\n    if (tb > 1) [ tb = tb - 1; ];\n    \n    if (tb < 0.166666666666667) [\n        b = p + (q - p) * 6 * tb;\n    ] else [\n        if (tb < 0.5) [\n            b = q;\n        ] else [\n            if (tb < 0.666666666666667) [\n                b = p + (q - p) * (0.666666666666667 - tb) * 6;\n            ] else [\n                b = p;\n            ];\n        ];\n    ];\n];\n\n// Create output\nvariable output: Color.SRGB;\noutput.r = r;\noutput.g = g;\noutput.b = b;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/",
-          "target": "$self",
-          "description": "Converts Linear sRGB to sRGB by applying gamma correction",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear sRGB to sRGB Conversion\n// Applies gamma correction (transfer function)\n// Reference: IEC 61966-2-1:1999 (sRGB specification)\n//\n// Algorithm:\n//   if linear ≤ 0.0031308: srgb = linear * 12.92\n//   else: srgb = 1.055 * linear^(1/2.4) - 0.055\n//\n// Input: Color.LinearSRGB with r, g, b in linear 0-1 range\n// Output: Color.SRGB with r, g, b in gamma-corrected 0-1 range\n\n// Gamma correction constants (IEC 61966-2-1)\nvariable threshold: Number = 0.0031308;\nvariable linear_scale: Number = 12.92;\nvariable gamma_offset: Number = 0.055;\nvariable gamma_scale: Number = 1.055;\nvariable gamma_exponent: Number = 0.416666666666667;\n\n// Get input linear values\nvariable linear_r: Number = {input}.r;\nvariable linear_g: Number = {input}.g;\nvariable linear_b: Number = {input}.b;\n\n// Convert red channel\nvariable srgb_r: Number = 0;\nif (linear_r <= threshold) [\n    srgb_r = linear_r * linear_scale;\n] else [\n    srgb_r = gamma_scale * pow(linear_r, gamma_exponent) - gamma_offset;\n];\n\n// Convert green channel\nvariable srgb_g: Number = 0;\nif (linear_g <= threshold) [\n    srgb_g = linear_g * linear_scale;\n] else [\n    srgb_g = gamma_scale * pow(linear_g, gamma_exponent) - gamma_offset;\n];\n\n// Convert blue channel\nvariable srgb_b: Number = 0;\nif (linear_b <= threshold) [\n    srgb_b = linear_b * linear_scale;\n] else [\n    srgb_b = gamma_scale * pow(linear_b, gamma_exponent) - gamma_offset;\n];\n\n// Create output\nvariable output: Color.SRGB;\noutput.r = srgb_r;\noutput.g = srgb_g;\noutput.b = srgb_b;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "srgb-color"
-    },
-    {
-      "name": "LinearSRGB",
-      "type": "color",
-      "description": "Linear sRGB color space (gamma-decoded). Used for matrix transformations to XYZ and other linear operations.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "r": {
-            "type": "number",
-            "description": "Linear red channel (0-1)"
-          },
-          "g": {
-            "type": "number",
-            "description": "Linear green channel (0-1)"
-          },
-          "b": {
-            "type": "number",
-            "description": "Linear blue channel (0-1)"
-          }
-        },
-        "required": [
-          "r",
-          "g",
-          "b"
-        ],
-        "order": [
-          "r",
-          "g",
-          "b"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "Linear sRGB Color Initializer",
-          "keyword": "linearsrgb",
-          "description": "Creates a linear sRGB color from linear 0-1 values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear sRGB Color Initializer\n// Creates a linear sRGB color from linear 0-1 values\n// Input: List of [r, g, b] linear values\n\nvariable color_values: List = {input};\nvariable output: Color.LinearSRGB;\n\noutput.r = color_values.get(0);\noutput.g = color_values.get(1);\noutput.b = color_values.get(2);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-          "target": "$self",
-          "description": "Converts sRGB to Linear sRGB by removing gamma correction (IEC 61966-2-1)",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// sRGB to Linear sRGB Conversion\n// Removes gamma correction (inverse transfer function)\n// Reference: IEC 61966-2-1:1999 (sRGB specification)\n//\n// Algorithm:\n//   if srgb ≤ 0.04045: linear = srgb / 12.92\n//   else: linear = ((srgb + 0.055) / 1.055) ^ 2.4\n//\n// Input: Color.SRGB with r, g, b in 0-1 range\n// Output: Color.LinearSRGB with r, g, b in linear 0-1 range\n\n// Gamma correction constants (IEC 61966-2-1)\nvariable threshold: Number = 0.04045;\nvariable linear_scale: Number = 12.92;\nvariable gamma_offset: Number = 0.055;\nvariable gamma_scale: Number = 1.055;\nvariable gamma_exponent: Number = 2.4;\n\n// Get input sRGB values\nvariable srgb_r: Number = {input}.r;\nvariable srgb_g: Number = {input}.g;\nvariable srgb_b: Number = {input}.b;\n\n// Convert red channel\nvariable linear_r: Number = 0;\nif (srgb_r <= threshold) [\n    linear_r = srgb_r / linear_scale;\n] else [\n    linear_r = pow((srgb_r + gamma_offset) / gamma_scale, gamma_exponent);\n];\n\n// Convert green channel\nvariable linear_g: Number = 0;\nif (srgb_g <= threshold) [\n    linear_g = srgb_g / linear_scale;\n] else [\n    linear_g = pow((srgb_g + gamma_offset) / gamma_scale, gamma_exponent);\n];\n\n// Convert blue channel\nvariable linear_b: Number = 0;\nif (srgb_b <= threshold) [\n    linear_b = srgb_b / linear_scale;\n] else [\n    linear_b = pow((srgb_b + gamma_offset) / gamma_scale, gamma_exponent);\n];\n\n// Create output\nvariable output: Color.LinearSRGB;\noutput.r = linear_r;\noutput.g = linear_g;\noutput.b = linear_b;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D65 to Linear sRGB using inverse transformation matrix",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D65 to Linear sRGB Conversion\n// Reference: ColorJS exact matrix values (extracted via unit vector conversion)\n//\n// Matrix (XYZ D65 to Linear sRGB):\n//   [ 3.2409699419045226, -1.537383177570094,  -0.4986107602930034 ]\n//   [-0.9692436362808796,  1.8759675015077202,  0.04155505740717559]\n//   [ 0.05563007969699366, -0.20397695888897652, 1.0569715142428786]\n//\n// Input: Color.XYZD65 with x, y, z tristimulus values\n// Output: Color.LinearSRGB with r, g, b in linear 0-1 range\n\n// Get input XYZ values\nvariable x: Number = {input}.x;\nvariable y: Number = {input}.y;\nvariable z: Number = {input}.z;\n\n// Apply inverse matrix transformation (ColorJS exact values)\n// Row 1: R\nvariable linear_r: Number = 3.2409699419045226 * x + -1.537383177570094 * y + -0.4986107602930034 * z;\n\n// Row 2: G\nvariable linear_g: Number = -0.9692436362808796 * x + 1.8759675015077202 * y + 0.04155505740717559 * z;\n\n// Row 3: B\nvariable linear_b: Number = 0.05563007969699366 * x + -0.20397695888897652 * y + 1.0569715142428786 * z;\n\n// Create output\nvariable output: Color.LinearSRGB;\noutput.r = linear_r;\noutput.g = linear_g;\noutput.b = linear_b;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "srgb-linear-color"
-    },
-    {
-      "name": "XYZD50",
-      "type": "color",
-      "description": "CIE XYZ color space with D50 white point. Used for Lab and LCH color spaces.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "x": {
-            "type": "number",
-            "description": "X tristimulus value"
-          },
-          "y": {
-            "type": "number",
-            "description": "Y tristimulus value (luminance)"
-          },
-          "z": {
-            "type": "number",
-            "description": "Z tristimulus value"
-          }
-        },
-        "required": [
-          "x",
-          "y",
-          "z"
-        ],
-        "order": [
-          "x",
-          "y",
-          "z"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "XYZ-D50 Color Initializer",
-          "keyword": "xyzd50",
-          "description": "Creates an XYZ-D50 color from tristimulus values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D50 Color Initializer\n// Creates an XYZ-D50 color from tristimulus values\n// Input: List of [x, y, z] tristimulus values\n\nvariable xyz_values: List = {input};\nvariable output: Color.XYZD50;\n\noutput.x = xyz_values.get(0);\noutput.y = xyz_values.get(1);\noutput.z = xyz_values.get(2);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/",
-          "target": "$self",
-          "description": "Converts XYZ-D65 to XYZ-D50 using Bradford chromatic adaptation",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D65 to XYZ-D50 Conversion\n// Chromatic adaptation using Bradford transform\n// Reference: https://github.com/color-js/color.js/blob/main/src/adapt.js\n//\n// Bradford CAT matrix for D65 → D50:\n// [1.0479298   0.0229469  -0.0501923]\n// [0.0296278   0.9904344  -0.0170738]\n// [-0.0092430  0.0150552   0.7518743]\n//\n// Input: Color.XYZD65 with x, y, z tristimulus (D65 white)\n// Output: Color.XYZD50 with x, y, z tristimulus (D50 white)\n\n// Get input XYZ-D65 values\nvariable x65: Number = {input}.x;\nvariable y65: Number = {input}.y;\nvariable z65: Number = {input}.z;\n\n// Bradford chromatic adaptation matrix (ColorJS exact values)\n// Row 1\nvariable x50: Number = x65 * 1.0479297925449969 + y65 * 0.022946870601609652 + z65 * -0.05019226628920524;\n// Row 2\nvariable y50: Number = x65 * 0.02962780877005599 + y65 * 0.9904344267538799 + z65 * -0.017073799063418826;\n// Row 3\nvariable z50: Number = x65 * -0.009243040646204504 + y65 * 0.015055191490298152 + z65 * 0.7518742814281371;\n\n// Create output\nvariable output: Color.XYZD50;\noutput.x = x50;\noutput.y = y50;\noutput.z = z50;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "xyz-d50-color"
-    },
-    {
-      "name": "XYZD65",
-      "type": "color",
-      "description": "CIE XYZ color space with D65 white point. The primary connection hub for color space conversions.",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "x": {
-            "type": "number",
-            "description": "X tristimulus value"
-          },
-          "y": {
-            "type": "number",
-            "description": "Y tristimulus value (luminance)"
-          },
-          "z": {
-            "type": "number",
-            "description": "Z tristimulus value"
-          }
-        },
-        "required": [
-          "x",
-          "y",
-          "z"
-        ],
-        "order": [
-          "x",
-          "y",
-          "z"
-        ],
-        "additionalProperties": false
-      },
-      "initializers": [
-        {
-          "title": "XYZ-D65 Color Initializer",
-          "keyword": "xyzd65",
-          "description": "Creates an XYZ-D65 color from tristimulus values",
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// XYZ-D65 Color Initializer\n// Creates an XYZ-D65 color from tristimulus values\n// Input: List of [x, y, z] tristimulus values\n\nvariable xyz_values: List = {input};\nvariable output: Color.XYZD65;\n\noutput.x = xyz_values.get(0);\noutput.y = xyz_values.get(1);\noutput.z = xyz_values.get(2);\n\nreturn output;"
-          }
-        }
-      ],
-      "conversions": [
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/",
-          "target": "$self",
-          "description": "Converts Linear sRGB to XYZ-D65 using the sRGB transformation matrix",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear sRGB to XYZ-D65 Conversion\n// Uses the sRGB primaries transformation matrix\n// Reference: IEC 61966-2-1:1999 (sRGB specification)\n//\n// Matrix (Linear RGB → XYZ-D65):\n// [X]   [0.4123908  0.3575843  0.1804808] [R]\n// [Y] = [0.2126390  0.7151687  0.0721923] [G]\n// [Z]   [0.0193308  0.1191948  0.9505322] [B]\n//\n// Input: Color.LinearSRGB with r, g, b in linear 0-1 range\n// Output: Color.XYZD65 with x, y, z tristimulus values\n\n// Get input linear sRGB values\nvariable r: Number = {input}.r;\nvariable g: Number = {input}.g;\nvariable b: Number = {input}.b;\n\n// Matrix multiplication: M × [R, G, B]ᵀ\n// Row 1: X = 0.4123908 * R + 0.3575843 * G + 0.1804808 * B\nvariable x: Number = r * 0.41239079926595934 + g * 0.357584339383878 + b * 0.1804807884018343;\n\n// Row 2: Y = 0.2126390 * R + 0.7151687 * G + 0.0721923 * B\nvariable y: Number = r * 0.21263900587151027 + g * 0.715168678767756 + b * 0.07219231536073371;\n\n// Row 3: Z = 0.0193308 * R + 0.1191948 * G + 0.9505322 * B\nvariable z: Number = r * 0.01933081871559182 + g * 0.11919477979462598 + b * 0.9505321522496607;\n\n// Create output\nvariable output: Color.XYZD65;\noutput.x = x;\noutput.y = y;\noutput.z = z;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/p3-linear-color/0/",
-          "target": "$self",
-          "description": "Converts Linear P3 to XYZ-D65 using the P3 transformation matrix",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// Linear P3 to XYZ-D65 Conversion\n// Converts linear Display-P3 RGB to CIE XYZ (D65)\n// Reference: CSS Color Level 4 specification\n//\n// Uses the P3 to XYZ-D65 transformation matrix\n// Matrix values from ColorJS / CSS Color Level 4\n//\n// Input: Color.LinearP3 with linear r, g, b values\n// Output: Color.XYZD65 with x, y, z tristimulus values\n\n// Get linear P3 values\nvariable r: Number = {input}.r;\nvariable g: Number = {input}.g;\nvariable b: Number = {input}.b;\n\n// Linear P3 to XYZ-D65 matrix\n// Row 1\nvariable m00: Number = 0.4865709486482162;\nvariable m01: Number = 0.26566769316909306;\nvariable m02: Number = 0.1982172852343625;\n\n// Row 2\nvariable m10: Number = 0.2289745640697488;\nvariable m11: Number = 0.6917385218365064;\nvariable m12: Number = 0.079286914093745;\n\n// Row 3\nvariable m20: Number = 0.0;\nvariable m21: Number = 0.04511338185890264;\nvariable m22: Number = 1.043944368900976;\n\n// Matrix multiplication: [x, y, z] = M × [r, g, b]\nvariable x: Number = m00 * r + m01 * g + m02 * b;\nvariable y: Number = m10 * r + m11 * g + m12 * b;\nvariable z: Number = m20 * r + m21 * g + m22 * b;\n\n// Create output\nvariable output: Color.XYZD65;\noutput.x = x;\noutput.y = y;\noutput.z = z;\n\nreturn output;"
-          }
-        },
-        {
-          "source": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-          "target": "$self",
-          "description": "Converts OKLab to XYZ-D65 using inverse LMS transformation",
-          "lossless": true,
-          "script": {
-            "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-            "script": "// OKLab to XYZ-D65 Conversion\n// Reference: ColorJS oklab.js (inverse transformation)\n//\n// Algorithm:\n// 1. Apply inverse Lab-to-LMS matrix to get LMS cone responses\n// 2. Cube the LMS values (inverse of cube root)\n// 3. Apply inverse LMS-to-XYZ matrix\n//\n// Input: Color.OKLab with l, a, b perceptual coordinates\n// Output: Color.XYZD65 with x, y, z tristimulus values\n\n// Get input OKLab values\nvariable ok_l: Number = {input}.l;\nvariable ok_a: Number = {input}.a;\nvariable ok_b: Number = {input}.b;\n\n// Inverse LMStoLab_M matrix (Lab to LMS')\n// These are the inverse of the matrix used in from-xyz-d65.tokenscript\nvariable lms_l: Number = 1.0 * ok_l + 0.3963377773761749 * ok_a + 0.2158037573099136 * ok_b;\nvariable lms_m: Number = 1.0 * ok_l + -0.1055613458156586 * ok_a + -0.0638541728258133 * ok_b;\nvariable lms_s: Number = 1.0 * ok_l + -0.0894841775298119 * ok_a + -1.2914855480194092 * ok_b;\n\n// Cube the values (inverse of cube root)\nvariable lms_l_cubed: Number = lms_l * lms_l * lms_l;\nvariable lms_m_cubed: Number = lms_m * lms_m * lms_m;\nvariable lms_s_cubed: Number = lms_s * lms_s * lms_s;\n\n// Inverse XYZtoLMS_M matrix (LMS to XYZ)\n// From ColorJS oklab.js\nvariable x: Number = 1.2268798758459243 * lms_l_cubed + -0.5578149944602171 * lms_m_cubed + 0.2813910456659647 * lms_s_cubed;\nvariable y: Number = -0.0405757452148008 * lms_l_cubed + 1.1122868032803170 * lms_m_cubed + -0.0717110580655164 * lms_s_cubed;\nvariable z: Number = -0.0763729366746601 * lms_l_cubed + -0.4214933324022432 * lms_m_cubed + 1.5869240198367816 * lms_s_cubed;\n\n// Create output\nvariable output: Color.XYZD65;\noutput.x = x;\noutput.y = y;\noutput.z = z;\n\nreturn output;"
-          }
-        }
-      ],
-      "slug": "xyz-d65-color"
-    }
-  ],
-  "functions": [
-    {
-      "name": "adjust_chroma",
-      "type": "function",
-      "description": "Adjusts a color's chroma by a relative amount. Positive values increase saturation, negative values decrease it. Unlike set_chroma which sets an absolute value, adjust_chroma adds to the current chroma. Result is clamped to valid range [0, ~0.4].",
-      "keyword": "adjust_chroma",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to adjust",
-                "type": "color"
-              },
-              {
-                "description": "Amount to adjust chroma (+/-)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with adjusted chroma"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// adjust_chroma: Adjust chroma by a relative amount\n//\n// Modifies the chroma (colorfulness) of a color by adding the\n// specified amount. Positive values increase saturation,\n// negative values decrease it. Result is clamped to [0, ∞).\n//\n// Uses OKLCH for perceptually uniform results.\n// Preserves lightness and hue.\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable amount: Number = input.get(1);\n\n// Calculate new chroma\nvariable new_c: Number = color.c + amount;\n\n// Clamp to valid range (chroma cannot be negative)\nif (new_c < 0) [ new_c = 0; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Increase saturation",
-          "input": [
-            "#808080",
-            0.1
-          ],
-          "output": "More saturated color"
-        },
-        {
-          "description": "Decrease saturation",
-          "input": [
-            "#ff6600",
-            -0.1
-          ],
-          "output": "Less saturated orange"
-        }
-      ],
-      "slug": "adjust_chroma"
-    },
-    {
-      "name": "adjust_hue",
-      "type": "function",
-      "description": "Adjusts a color's hue by a relative amount in degrees. Positive values rotate clockwise, negative values counter-clockwise. Unlike set_hue which sets an absolute value, adjust_hue adds to the current hue. Uses OKLCH for perceptually uniform hue rotation.",
-      "keyword": "adjust_hue",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to adjust",
-                "type": "color"
-              },
-              {
-                "description": "Degrees to rotate hue (+ or -)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with adjusted hue"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// adjust_hue: Rotate hue by a relative angle\n//\n// Adds the specified degrees to the color's hue, wrapping\n// around the 360° color wheel. Positive values rotate clockwise,\n// negative values rotate counter-clockwise.\n//\n// Uses OKLCH for perceptually uniform hue rotation.\n// Preserves lightness and chroma.\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable degrees: Number = input.get(1);\n\n// Calculate new hue\nvariable new_h: Number = color.h + degrees;\n\n// Normalize to 0-360\nwhile (new_h < 0) [\n    new_h = new_h + 360;\n];\nwhile (new_h >= 360) [\n    new_h = new_h - 360;\n];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = new_h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Shift red toward orange",
-          "input": [
-            "#ff0000",
-            30
-          ],
-          "output": "Orange color"
-        },
-        {
-          "description": "Shift blue toward green",
-          "input": [
-            "#0000ff",
-            -60
-          ],
-          "output": "Cyan color"
-        }
-      ],
-      "slug": "adjust_hue"
-    },
-    {
-      "name": "adjust_lightness",
-      "type": "function",
-      "description": "Adjusts a color's lightness by a relative amount. Positive values make it lighter, negative values make it darker. Unlike set_lightness which sets an absolute value, adjust_lightness adds to the current lightness. Result is clamped to valid range [0, 1].",
-      "keyword": "adjust_lightness",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to adjust",
-                "type": "color"
-              },
-              {
-                "description": "Amount to adjust lightness (+/-)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with adjusted lightness"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// adjust_lightness: Adjust lightness by a relative amount\n//\n// Modifies the lightness of a color by adding the specified\n// amount. Positive values lighten, negative values darken.\n// Result is clamped to [0, 1].\n//\n// Preserves hue and chroma.\n//\n// Input:  Any color space (converted to OKLCH internally)\n// Output: OKLCH (working space)\n// To get sRGB: adjust_lightness(color, 0.2).to.srgb()\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable amount: Number = input.get(1);\n\n// Calculate new lightness\nvariable new_l: Number = color.l + amount;\n\n// Clamp to valid range\nif (new_l < 0) [ new_l = 0; ];\nif (new_l > 1) [ new_l = 1; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = new_l;\nresult.c = color.c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Lighten a color",
-          "input": [
-            "#808080",
-            0.2
-          ],
-          "output": "Lighter gray"
-        },
-        {
-          "description": "Darken a color",
-          "input": [
-            "#808080",
-            -0.3
-          ],
-          "output": "Darker gray"
-        }
-      ],
-      "slug": "adjust_lightness"
-    },
-    {
-      "name": "adjust_to_contrast",
-      "type": "function",
-      "description": "Adjusts a foreground color's lightness to achieve a target WCAG contrast ratio against a background. Preserves hue and chroma while finding the optimal lightness. Uses binary search in OKLCH space for perceptually even adjustments. If target contrast cannot be achieved (e.g., trying to get 21:1 with mid-gray), returns the best possible result.",
-      "keyword": "adjust_to_contrast",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Foreground color to adjust",
-                "type": "color"
-              },
-              {
-                "description": "Background color (fixed)",
-                "type": "color"
-              },
-              {
-                "description": "Target contrast ratio (default 4.5 for WCAG AA)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 3
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Adjusted foreground color meeting the target contrast"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// adjust_to_contrast: Adjust foreground to meet target WCAG contrast ratio\n// Reference: WCAG 2.1 Contrast Ratio Definition\n// Reference: https://www.w3.org/TR/WCAG21/#dfn-contrast-ratio\n//\n// Modifies the foreground color's lightness (in OKLCH) to achieve\n// the specified contrast ratio against the background, while\n// preserving hue and chroma.\n//\n// Parameters:\n//   foreground   - Color to adjust\n//   background   - Reference background color\n//   target_ratio - Minimum contrast ratio (default: 4.5 for WCAG AA)\n//\n// Uses binary search in OKLCH lightness for convergence.\n//\n// Input:  Any color space (converted to OKLCH internally)\n// Output: OKLCH (working space)\n// To get sRGB: adjust_to_contrast(fg, bg, 4.5).to.srgb()\n\nvariable input: List = {input};\nvariable foreground: Color.OKLCH = input.get(0).to.oklch();\nvariable bg_xyz: Color.XYZD65 = input.get(1).to.xyzd65();\n\n// Default to WCAG AA for normal text\nvariable target_ratio: Number = 4.5;\nif (input.length() > 2) [\n    target_ratio = input.get(2);\n];\n\n// Get background luminance\nvariable bg_lum: Number = bg_xyz.y;\n\n// Determine if we need to go lighter or darker\n// Test with current foreground\nvariable test_oklch: Color.OKLCH;\ntest_oklch.l = foreground.l;\ntest_oklch.c = foreground.c;\ntest_oklch.h = foreground.h;\n\nvariable test_xyz: Color.XYZD65 = test_oklch.to.srgb().to.xyzd65();\nvariable fg_lum: Number = test_xyz.y;\n\n// Calculate current contrast\nvariable l1: Number = fg_lum;\nvariable l2: Number = bg_lum;\nif (l2 > l1) [\n    l1 = bg_lum;\n    l2 = fg_lum;\n];\nvariable current_ratio: Number = (l1 + 0.05) / (l2 + 0.05);\n\n// If already meets target, return as-is (in OKLCH working space)\nif (current_ratio >= target_ratio) [\n    return foreground;\n];\n\n// Determine direction: if background is dark, we need lighter foreground and vice versa\nvariable search_min: Number = 0;\nvariable search_max: Number = 1;\n\n// Binary search for correct lightness\nvariable epsilon: Number = 0.001;\nvariable iterations: Number = 0;\nvariable max_iterations: Number = 30;\nvariable best_l: Number = foreground.l;\nvariable best_ratio: Number = current_ratio;\n\nvariable diff: Number = search_max - search_min;\nvariable mid_l: Number = 0.5;\nvariable test_ratio: Number = 1;\n\nwhile (diff > epsilon) [\n    if (iterations >= max_iterations) [\n        diff = 0;  // Force exit\n    ];\n    mid_l = (search_min + search_max) / 2;\n    \n    // Test this lightness\n    test_oklch.l = mid_l;\n    test_oklch.c = foreground.c;\n    test_oklch.h = foreground.h;\n    \n    // Convert to get luminance\n    test_xyz = test_oklch.to.srgb().to.xyzd65();\n    fg_lum = test_xyz.y;\n    \n    // Calculate contrast\n    l1 = fg_lum;\n    l2 = bg_lum;\n    if (l2 > l1) [\n        l1 = bg_lum;\n        l2 = fg_lum;\n    ];\n    test_ratio = (l1 + 0.05) / (l2 + 0.05);\n    \n    // Track best result\n    if (test_ratio >= target_ratio) [\n        // This lightness works, but can we get closer to original?\n        // If background is dark (low lum), we want darker foreground closer to original\n        // If background is light (high lum), we want lighter foreground closer to original\n        if (bg_lum < 0.18) [\n            // Dark background: search lower (darker)\n            search_max = mid_l;\n        ] else [\n            // Light background: search higher (lighter)\n            search_min = mid_l;\n        ];\n        best_l = mid_l;\n        best_ratio = test_ratio;\n    ] else [\n        // Not enough contrast, need more separation\n        if (bg_lum < 0.18) [\n            // Dark background: need lighter foreground\n            search_min = mid_l;\n        ] else [\n            // Light background: need darker foreground\n            search_max = mid_l;\n        ];\n    ];\n    \n    iterations = iterations + 1;\n    diff = search_max - search_min;\n];\n\n// Apply best lightness found, return in OKLCH working space\nvariable result: Color.OKLCH;\nresult.l = best_l;\nresult.c = foreground.c;\nresult.h = foreground.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Adjust light gray to meet AA on white",
-          "input": [
-            "#cccccc",
-            "#ffffff",
-            4.5
-          ],
-          "output": "Darkened gray meeting 4.5:1"
-        },
-        {
-          "description": "Adjust brand color for accessibility",
-          "input": [
-            "#6750a4",
-            "#ffffff",
-            4.5
-          ],
-          "output": "Adjusted purple meeting 4.5:1"
-        }
-      ],
-      "slug": "adjust_to_contrast"
-    },
-    {
-      "name": "Alpha Blend",
-      "type": "function",
-      "description": "Performs Porter-Duff 'over' compositing to blend a foreground color over a background color using the foreground's alpha. Formula: result = fg × α + bg × (1-α). Standard alpha compositing used in CSS and graphics software.",
-      "keyword": "alpha_blend",
-      "input": {
-        "type": "object",
-        "properties": {
-          "foreground": {
-            "type": "color",
-            "description": "Foreground (top) color"
-          },
-          "background": {
-            "type": "color",
-            "description": "Background (bottom) color"
-          },
-          "alpha": {
-            "type": "number",
-            "description": "Opacity of foreground (0-1, default: 0.5)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Alpha Blend (Porter-Duff Over Compositing)\n// Reference: Porter & Duff \"Compositing Digital Images\" (1984)\n// Reference: W3C CSS Color Level 4 - Alpha Compositing\n//\n// Formula: result = foreground × α + background × (1 - α)\n// \n// This is the standard \"over\" operation:\n// - α = 0: result is entirely background\n// - α = 1: result is entirely foreground\n// - 0 < α < 1: blend of both colors\n//\n// Used in:\n// - CSS opacity and rgba\n// - Semi-transparent overlays\n// - Gradient stops\n// - Glass/frosted effects\n\nvariable input: List = {input};\nvariable fg: Color.SRGB = input.get(0).to.srgb();\nvariable bg: Color.SRGB = input.get(1).to.srgb();\n\n// Default alpha is 0.5 (50% opacity)\nvariable alpha: Number = 0.5;\nif (input.length() > 2) [\n    alpha = input.get(2);\n];\n\n// Clamp alpha to valid range\nif (alpha < 0) [ alpha = 0; ];\nif (alpha > 1) [ alpha = 1; ];\n\n// Porter-Duff \"over\" compositing\nvariable inv_alpha: Number = 1 - alpha;\n\nvariable r: Number = fg.r * alpha + bg.r * inv_alpha;\nvariable g: Number = fg.g * alpha + bg.g * inv_alpha;\nvariable b: Number = fg.b * alpha + bg.b * inv_alpha;\n\n// Create result\nvariable result: Color.SRGB;\nresult.r = r;\nresult.g = g;\nresult.b = b;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "alpha_blend"
-    },
-    {
-      "name": "Alpha Scale",
-      "type": "function",
-      "description": "Generates transparency variants of a color. Returns colors with progressively lower opacity. Perfect for overlays, shadows, and layered UI elements.",
-      "keyword": "alpha_scale",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of alpha steps. Default is 10"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate alpha/transparency scale\n// Returns colors from 100% opacity down to nearly transparent\n//\n// Default 10 steps: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%\n// Useful for: overlays, shadows, backgrounds, hover states\n\nvariable input: List = {input};\nvariable base: Color.SRGB = input.get(0).to.srgb();\n\nvariable count: Number = 10;\nif (input.length() > 1) [\n    count = input.get(1);\n];\n\nvariable result: List;\nvariable i: Number = 0;\nvariable step_alpha: Number = 0;\nvariable step_color: Color.SRGB;\n\nwhile (i < count) [\n    // Alpha from 1.0 down to 0.1\n    step_alpha = 1 - (i / count);\n    \n    // Create color with alpha\n    // Note: This creates the color value; actual alpha handling\n    // depends on how the consuming system processes the output\n    step_color.r = base.r;\n    step_color.g = base.g;\n    step_color.b = base.b;\n    \n    // Store alpha as 4th value (RGBA convention)\n    // Use .to.srgb() to create a new color instance for each step\n    result = result, step_color.to.srgb(), step_alpha;\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "alpha_scale"
-    },
-    {
-      "name": "Analogous",
-      "type": "function",
-      "description": "Generates analogous colors - hues adjacent on the color wheel. Creates harmonious, low-contrast palettes. Perfect for backgrounds and subtle variations.",
-      "keyword": "analogous",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of colors (odd recommended). Default is 5"
-          },
-          "spread": {
-            "type": "number",
-            "description": "Total angle spread in degrees. Default is 60"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate analogous colors (adjacent hues)\n// Colors are spread evenly around the base hue\n//\n// Use case: Harmonious, subtle palettes\n// Example: 5 colors with 60° spread = -30°, -15°, 0°, +15°, +30°\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\nvariable count: Number = 5;\nif (input.length() > 1) [\n    count = input.get(1);\n];\n\nvariable spread: Number = 60;\nif (input.length() > 2) [\n    spread = input.get(2);\n];\n\n// Calculate step size and starting offset\nvariable step: Number = spread / (count - 1);\nvariable start_offset: Number = 0 - spread / 2;\n\nvariable result: List;\nvariable i: Number = 0;\nvariable hue_offset: Number = 0;\nvariable new_hue: Number = 0;\nvariable color: Color.OKLCH;\n\nwhile (i < count) [\n    hue_offset = start_offset + i * step;\n    new_hue = base.h + hue_offset;\n    \n    // Normalize hue to 0-360\n    if (new_hue < 0) [ new_hue = new_hue + 360; ];\n    if (new_hue >= 360) [ new_hue = new_hue - 360; ];\n    \n    color.l = base.l;\n    color.c = base.c;\n    color.h = new_hue;\n    \n    result = result, color.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "analogous"
-    },
-    {
-      "name": "APCA Contrast",
-      "type": "function",
-      "description": "Calculates APCA (Accessible Perceptual Contrast Algorithm) contrast between text and background colors. APCA is part of WCAG 3.0 draft and provides perceptually uniform contrast values. Returns Lc value from -108 to +106. Positive = light text on dark, negative = dark text on light. |Lc| ≥ 60 recommended for body text.",
-      "keyword": "apca_contrast",
-      "input": {
-        "type": "object",
-        "properties": {
-          "text": {
-            "type": "color",
-            "description": "Text/foreground color"
-          },
-          "background": {
-            "type": "color",
-            "description": "Background color"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// APCA Contrast (Accessible Perceptual Contrast Algorithm)\n// Version: APCA 0.0.98G (W3C/WCAG 3.0 Draft)\n// Reference: https://github.com/Myndex/apca-w3\n// Reference: https://www.w3.org/TR/wcag-3.0/#visual-contrast-of-text\n//\n// Returns Lc (Lightness contrast) value:\n//   - Range: approximately -108 to +106\n//   - Positive values: light text on dark background\n//   - Negative values: dark text on light background\n//   - |Lc| >= 75: Preferred for body text\n//   - |Lc| >= 60: Minimum for body text\n//   - |Lc| >= 45: Minimum for large text (≥24px)\n//   - |Lc| >= 30: Minimum for non-text elements\n//\n// Algorithm:\n// 1. Convert to sRGB and linearize with simple 2.4 gamma\n// 2. Calculate screen luminance Y with sRGB coefficients\n// 3. Apply soft black clamp for flare compensation\n// 4. Calculate contrast with asymmetric formula (BoW vs WoB)\n// 5. Apply low clip and offset\n\nvariable input: List = {input};\nvariable text: Color.SRGB = input.get(0).to.srgb();\nvariable bg: Color.SRGB = input.get(1).to.srgb();\n\n// APCA Constants (from specification)\n// Exponents\nvariable norm_bg: Number = 0.56;\nvariable norm_txt: Number = 0.57;\nvariable rev_txt: Number = 0.62;\nvariable rev_bg: Number = 0.65;\n\n// Soft black clamp constants\nvariable blk_thrs: Number = 0.022;\nvariable blk_clmp: Number = 1.414;\n\n// Low clip (noise gate)\nvariable lo_clip: Number = 0.1;\nvariable delta_y_min: Number = 0.0005;\n\n// Scalers and offset\nvariable scale_bow: Number = 1.14;\nvariable scale_wob: Number = 1.14;\nvariable lo_offset: Number = 0.027;\n\n// Linearize sRGB with simple 2.4 gamma (NOT full sRGB transfer function)\n// This is per APCA specification which uses simplified gamma\nvariable text_r: Number = text.r;\nvariable text_g: Number = text.g;\nvariable text_b: Number = text.b;\nvariable bg_r: Number = bg.r;\nvariable bg_g: Number = bg.g;\nvariable bg_b: Number = bg.b;\n\n// Handle negative values (out of gamut)\nif (text_r < 0) [ text_r = 0 - text_r; ];\nif (text_g < 0) [ text_g = 0 - text_g; ];\nif (text_b < 0) [ text_b = 0 - text_b; ];\nif (bg_r < 0) [ bg_r = 0 - bg_r; ];\nif (bg_g < 0) [ bg_g = 0 - bg_g; ];\nif (bg_b < 0) [ bg_b = 0 - bg_b; ];\n\n// Linearize with 2.4 gamma\nvariable lin_text_r: Number = pow(text_r, 2.4);\nvariable lin_text_g: Number = pow(text_g, 2.4);\nvariable lin_text_b: Number = pow(text_b, 2.4);\nvariable lin_bg_r: Number = pow(bg_r, 2.4);\nvariable lin_bg_g: Number = pow(bg_g, 2.4);\nvariable lin_bg_b: Number = pow(bg_b, 2.4);\n\n// Calculate screen luminance Y using sRGB coefficients\n// Coefficients from Myndex/APCA spec (via Lindbloom)\nvariable y_text: Number = 0.2126729 * lin_text_r + 0.7151522 * lin_text_g + 0.0721750 * lin_text_b;\nvariable y_bg: Number = 0.2126729 * lin_bg_r + 0.7151522 * lin_bg_g + 0.0721750 * lin_bg_b;\n\n// Soft clamp for flare (low luminance adjustment)\n// If Y >= threshold, use Y as-is\n// Otherwise: Y + (threshold - Y)^1.414\nvariable y_txt_clamped: Number = y_text;\nvariable y_bg_clamped: Number = y_bg;\n\nif (y_text < blk_thrs) [\n    variable diff_txt: Number = blk_thrs - y_text;\n    y_txt_clamped = y_text + pow(diff_txt, blk_clmp);\n];\n\nif (y_bg < blk_thrs) [\n    variable diff_bg: Number = blk_thrs - y_bg;\n    y_bg_clamped = y_bg + pow(diff_bg, blk_clmp);\n];\n\n// Determine polarity: BoW (dark on light) or WoB (light on dark)\nvariable sapc: Number = 0;\nvariable s_contrast: Number = 0;\n\n// Noise gate check\nvariable y_diff: Number = y_bg_clamped - y_txt_clamped;\nif (y_diff < 0) [ y_diff = 0 - y_diff; ];\n\n// Negative lo_clip for comparison (avoid parsing issues)\nvariable neg_lo_clip: Number = 0 - lo_clip;\n\nif (y_diff >= delta_y_min) [\n    if (y_bg_clamped > y_txt_clamped) [\n        // BoW: Dark text on light background (returns POSITIVE per APCA spec)\n        s_contrast = pow(y_bg_clamped, norm_bg) - pow(y_txt_clamped, norm_txt);\n        sapc = s_contrast * scale_bow;\n        \n        if (sapc < lo_clip) [\n            sapc = 0;\n        ] else [\n            sapc = sapc - lo_offset;\n        ];\n    ] else [\n        // WoB: Light text on dark background (returns NEGATIVE per APCA spec)\n        s_contrast = pow(y_bg_clamped, rev_bg) - pow(y_txt_clamped, rev_txt);\n        sapc = s_contrast * scale_wob;\n        \n        if (sapc > neg_lo_clip) [\n            sapc = 0;\n        ] else [\n            sapc = sapc + lo_offset;\n        ];\n    ];\n];\n\n// Return Lc * 100 (standard APCA output format)\nreturn sapc * 100;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "apca_contrast"
-    },
-    {
-      "name": "are_similar",
-      "type": "function",
-      "description": "Determines if two colors are perceptually similar using Delta E OK (Euclidean distance in OKLab space). Returns true if the colors are within the specified threshold. Default threshold of 0.02 corresponds to a 'just noticeable difference' (JND). Based on Björn Ottosson's OKLab color space which provides excellent perceptual uniformity.",
-      "keyword": "are_similar",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "First color",
-                "type": "color"
-              },
-              {
-                "description": "Second color",
-                "type": "color"
-              },
-              {
-                "description": "Delta E threshold (default 0.02 ≈ JND)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 3
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "boolean",
-        "description": "True if colors are perceptually similar (within threshold)"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// are_similar: Check if two colors are perceptually similar\n// Uses Delta E OK (OKLab Euclidean distance) for perceptual comparison\n// Default threshold 0.02 approximates \"just noticeable difference\"\n\nvariable input: List = {input};\nvariable color1: Color.OKLab = input.get(0).to.oklab();\nvariable color2: Color.OKLab = input.get(1).to.oklab();\n\n// Default threshold for JND (just noticeable difference)\nvariable threshold: Number = 0.02;\nif (input.length() > 2) [\n    threshold = input.get(2);\n];\n\n// Calculate Delta E OK (Euclidean distance in OKLab)\nvariable delta_l: Number = color1.l - color2.l;\nvariable delta_a: Number = color1.a - color2.a;\nvariable delta_b: Number = color1.b - color2.b;\n\nvariable delta_e: Number = sqrt(delta_l * delta_l + delta_a * delta_a + delta_b * delta_b);\n\n// Return true if within threshold\nreturn delta_e <= threshold;"
-      },
-      "examples": [
-        {
-          "description": "Nearly identical colors",
-          "input": [
-            "#ff0000",
-            "#ff0001"
-          ],
-          "output": true
-        },
-        {
-          "description": "Obviously different colors",
-          "input": [
-            "#ff0000",
-            "#00ff00"
-          ],
-          "output": false
-        },
-        {
-          "description": "Custom threshold for stricter comparison",
-          "input": [
-            "#808080",
-            "#818181",
-            0.01
-          ],
-          "output": true
-        }
-      ],
-      "slug": "are_similar"
-    },
-    {
-      "name": "auto_text_color",
-      "type": "function",
-      "description": "Returns black or white text color for optimal contrast against a background. Uses WCAG relative luminance to determine if the background is light or dark, then returns the opposite for maximum readability. Essential for generating accessible text colors in design systems.",
-      "keyword": "auto_text_color",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Background color to test",
-                "type": "color"
-              },
-              {
-                "description": "Optional threshold (0-1, default 0.179 per WCAG). Higher values bias toward white text.",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Either black (#000000) or white (#ffffff) for optimal contrast"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// auto_text_color: Select black or white text for optimal contrast\n// Reference: WCAG 2.1 Relative Luminance\n// Reference: https://www.w3.org/TR/WCAG21/#dfn-relative-luminance\n//\n// Returns black (#000) or white (#fff) depending on which provides\n// better contrast against the input background color.\n//\n// Default threshold: 0.179 (geometric mean of WCAG luminance range)\n// - sqrt(1.05 * 0.05) - 0.05 ≈ 0.179\n// - Above threshold: light background → black text\n// - Below threshold: dark background → white text\n\nvariable input: List = {input};\n\n// Default threshold based on WCAG luminance midpoint\nvariable threshold: Number = 0.179;\nif (input.length() > 1) [\n    threshold = input.get(1);\n];\n\n// Convert to XYZ-D65 to get relative luminance (Y component)\nvariable xyz: Color.XYZD65 = input.get(0).to.xyzd65();\nvariable luminance: Number = xyz.y;\n\n// If luminance is above threshold, background is \"light\" -> use black text\n// If luminance is below threshold, background is \"dark\" -> use white text\nvariable result: Color.SRGB;\n\nif (luminance > threshold) [\n    // Light background: return black\n    result.r = 0;\n    result.g = 0;\n    result.b = 0;\n] else [\n    // Dark background: return white\n    result.r = 1;\n    result.g = 1;\n    result.b = 1;\n];\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Dark background returns white text",
-          "input": [
-            "#1a1a1a"
-          ],
-          "output": "#ffffff"
-        },
-        {
-          "description": "Light background returns black text",
-          "input": [
-            "#f0f0f0"
-          ],
-          "output": "#000000"
-        },
-        {
-          "description": "Mid-tone with custom threshold",
-          "input": [
-            "#808080",
-            0.5
-          ],
-          "output": "#ffffff"
-        }
-      ],
-      "slug": "auto_text_color"
-    },
-    {
-      "name": "Best Contrast",
-      "type": "function",
-      "description": "Selects the color with highest contrast against a background from a list of candidates. Uses WCAG 2.1 contrast ratio. Perfect for choosing readable text colors.",
-      "keyword": "best_contrast",
-      "input": {
-        "type": "object",
-        "properties": {
-          "background": {
-            "type": "color",
-            "description": "The background color to contrast against"
-          },
-          "candidates": {
-            "type": "list",
-            "description": "List of candidate colors to choose from. Default is [black, white]"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Select the most contrasting color from a list of candidates\n// Uses WCAG 2.1 contrast ratio based on relative luminance\n//\n// Algorithm:\n// 1. Calculate relative luminance: L = 0.2126*R + 0.7152*G + 0.0722*B (linear RGB)\n// 2. Contrast ratio: (L_lighter + 0.05) / (L_darker + 0.05)\n// 3. Return candidate with highest contrast ratio\n//\n// Default candidates: black (#000) and white (#fff)\n\nvariable input: List = {input};\nvariable bg: Color.LinearSRGB = input.get(0).to.linearsrgb();\n\n// Calculate background luminance\nvariable bg_lum: Number = 0.2126 * bg.r + 0.7152 * bg.g + 0.0722 * bg.b;\n\n// Get candidates list, default to black and white\nvariable candidates: List;\nif (input.length() > 1) [\n    candidates = input.get(1);\n] else [\n    // Default: black and white\n    variable black: Color.SRGB;\n    black.r = 0; black.g = 0; black.b = 0;\n    variable white: Color.SRGB;\n    white.r = 1; white.g = 1; white.b = 1;\n    candidates = black, white;\n];\n\n// Find candidate with highest contrast\nvariable best_color: Color.SRGB = candidates.get(0).to.srgb();\nvariable best_contrast: Number = 0;\nvariable candidate: Color.LinearSRGB;\nvariable cand_lum: Number = 0;\nvariable lighter: Number = 0;\nvariable darker: Number = 0;\nvariable contrast: Number = 0;\n\nvariable i: Number = 0;\nwhile (i < candidates.length()) [\n    candidate = candidates.get(i).to.linearsrgb();\n    \n    // Calculate candidate luminance\n    cand_lum = 0.2126 * candidate.r + 0.7152 * candidate.g + 0.0722 * candidate.b;\n    \n    // Calculate contrast ratio (lighter / darker)\n    lighter = bg_lum;\n    darker = cand_lum;\n    if (cand_lum > bg_lum) [\n        lighter = cand_lum;\n        darker = bg_lum;\n    ];\n    \n    contrast = (lighter + 0.05) / (darker + 0.05);\n    \n    // Track best\n    if (contrast > best_contrast) [\n        best_contrast = contrast;\n        best_color = candidates.get(i).to.srgb();\n    ];\n    \n    i = i + 1;\n];\n\nreturn best_color;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "best_contrast"
-    },
-    {
-      "name": "chroma",
-      "type": "function",
-      "description": "Extracts the chroma (colorfulness/saturation) value from any color using OKLCH. Returns a value from 0 (gray) to approximately 0.4 (most saturated colors). Chroma in OKLCH represents the colorfulness independent of lightness - higher values mean more vivid colors. Essential for creating consistent color scales and checking color vibrancy.",
-      "keyword": "chroma",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to extract chroma from",
-                "type": "color"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 1
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "number",
-        "description": "Chroma value (0 to ~0.4)"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// chroma: Extract chroma (colorfulness) from a color\n// Reference: OKLCH Color Space (Björn Ottosson)\n// Reference: https://bottosson.github.io/posts/oklab/\n//\n// Returns the C component from OKLCH, which represents\n// colorfulness/saturation. Range: 0 (gray) to ~0.4 (most vivid).\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\nreturn color.c;"
-      },
-      "examples": [
-        {
-          "description": "Gray has chroma 0",
-          "input": [
-            "#808080"
-          ],
-          "output": 0
-        },
-        {
-          "description": "Saturated red has high chroma",
-          "input": [
-            "#ff0000"
-          ],
-          "output": 0.26
-        }
-      ],
-      "slug": "chroma"
-    },
-    {
-      "name": "clamp_chroma",
-      "type": "function",
-      "description": "Constrains a color's chroma (saturation) to a specified range while preserving hue and lightness. Useful for ensuring colors stay within brand guidelines or design constraints. Uses OKLCH for perceptually uniform clamping.",
-      "keyword": "clamp_chroma",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to clamp",
-                "type": "color"
-              },
-              {
-                "description": "Minimum chroma (0+)",
-                "type": "number"
-              },
-              {
-                "description": "Maximum chroma (typically 0-0.4)",
-                "type": "number"
-              }
-            ],
-            "minItems": 3,
-            "maxItems": 3
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with clamped chroma"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// clamp_chroma: Constrain chroma to a range\n// Preserves hue and lightness\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable min_c: Number = input.get(1);\nvariable max_c: Number = input.get(2);\n\n// Clamp chroma\nvariable new_c: Number = color.c;\nif (new_c < min_c) [ new_c = min_c; ];\nif (new_c > max_c) [ new_c = max_c; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Limit maximum saturation",
-          "input": [
-            "#ff0000",
-            0,
-            0.15
-          ],
-          "output": "Muted red with chroma 0.15"
-        },
-        {
-          "description": "Ensure minimum saturation",
-          "input": [
-            "#808080",
-            0.05,
-            0.3
-          ],
-          "output": "Slightly colored gray"
-        }
-      ],
-      "slug": "clamp_chroma"
-    },
-    {
-      "name": "clamp_lightness",
-      "type": "function",
-      "description": "Constrains a color's lightness to a specified range while preserving hue and chroma. Useful for ensuring colors stay within readable/accessible bounds. Uses OKLCH for perceptually uniform clamping.",
-      "keyword": "clamp_lightness",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to clamp",
-                "type": "color"
-              },
-              {
-                "description": "Minimum lightness (0-1)",
-                "type": "number"
-              },
-              {
-                "description": "Maximum lightness (0-1)",
-                "type": "number"
-              }
-            ],
-            "minItems": 3,
-            "maxItems": 3
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with clamped lightness"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// clamp_lightness: Constrain lightness to a range\n// Preserves hue and chroma\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable min_l: Number = input.get(1);\nvariable max_l: Number = input.get(2);\n\n// Clamp lightness\nvariable new_l: Number = color.l;\nif (new_l < min_l) [ new_l = min_l; ];\nif (new_l > max_l) [ new_l = max_l; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = new_l;\nresult.c = color.c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Clamp too-dark color to minimum",
-          "input": [
-            "#111111",
-            0.3,
-            0.9
-          ],
-          "output": "Color with lightness 0.3"
-        },
-        {
-          "description": "Clamp too-light color to maximum",
-          "input": [
-            "#ffffff",
-            0.2,
-            0.8
-          ],
-          "output": "Color with lightness 0.8"
-        }
-      ],
-      "slug": "clamp_lightness"
-    },
-    {
-      "name": "Clamp to Gamut",
-      "type": "function",
-      "description": "Clips a color to the sRGB gamut by clamping each RGB channel to [0,1]. This is a simple but lossy approach - for perceptually better results, consider using gamut mapping algorithms that reduce chroma first.",
-      "keyword": "clamp_to_gamut",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Color to clamp"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Clamp to Gamut (Simple Clipping)\n// Clips out-of-gamut sRGB values to [0, 1] range\n// Reference: Color.js toGamut with method=\"clip\"\n//\n// This is the simplest gamut mapping approach:\n// - Fast and deterministic\n// - Preserves hue when only one channel clips\n// - Can cause hue shifts when multiple channels clip\n// - May lose saturation detail\n//\n// For perceptually better results, use toGamut() which\n// reduces chroma in OKLCH before clipping.\n\nvariable input: List = {input};\nvariable color: Color.SRGB = input.get(0).to.srgb();\n\n// Get RGB values\nvariable r: Number = color.r;\nvariable g: Number = color.g;\nvariable b: Number = color.b;\n\n// Clamp R\nif (r < 0) [ r = 0; ];\nif (r > 1) [ r = 1; ];\n\n// Clamp G\nif (g < 0) [ g = 0; ];\nif (g > 1) [ g = 1; ];\n\n// Clamp B\nif (b < 0) [ b = 0; ];\nif (b > 1) [ b = 1; ];\n\n// Create clamped result\nvariable result: Color.SRGB;\nresult.r = r;\nresult.g = g;\nresult.b = b;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "clamp_to_gamut"
-    },
-    {
-      "name": "Complement",
-      "type": "function",
-      "description": "Returns the complementary color by rotating hue 180° in OKLCH space.",
-      "keyword": "complement",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to find the complement of"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Get the complementary color by rotating hue 180° in OKLCH\n// Preserves lightness and chroma for perceptually balanced results\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Rotate hue by 180°\nvariable new_h: Number = color.h + 180;\nif (new_h >= 360) [ new_h = new_h - 360; ];\n\n// Create complementary color\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = new_h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "complement"
-    },
-    {
-      "name": "Contrast Ratio",
-      "type": "function",
-      "description": "Calculates the WCAG 2.1 contrast ratio between two colors. Returns a value from 1 (no contrast) to 21 (black/white). WCAG AA requires 4.5:1 for normal text, 3:1 for large text.",
-      "keyword": "contrast_ratio",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color (e.g., background)"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color (e.g., foreground)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Calculate WCAG 2.1 contrast ratio between two colors\n//\n// Returns: 1.0 (identical) to 21.0 (black vs white)\n//\n// WCAG Guidelines:\n//   - AA Normal text: ≥ 4.5:1\n//   - AA Large text:  ≥ 3.0:1\n//   - AAA Normal text: ≥ 7.0:1\n//   - AAA Large text:  ≥ 4.5:1\n//\n// Algorithm:\n// 1. Convert to linear RGB\n// 2. Calculate relative luminance: L = 0.2126*R + 0.7152*G + 0.0722*B\n// 3. Contrast ratio: (L_lighter + 0.05) / (L_darker + 0.05)\n\nvariable input: List = {input};\nvariable color1: Color.LinearSRGB = input.get(0).to.linearsrgb();\nvariable color2: Color.LinearSRGB = input.get(1).to.linearsrgb();\n\n// Calculate relative luminance for each color\nvariable lum1: Number = 0.2126 * color1.r + 0.7152 * color1.g + 0.0722 * color1.b;\nvariable lum2: Number = 0.2126 * color2.r + 0.7152 * color2.g + 0.0722 * color2.b;\n\n// Determine lighter and darker\nvariable lighter: Number = lum1;\nvariable darker: Number = lum2;\nif (lum2 > lum1) [\n    lighter = lum2;\n    darker = lum1;\n];\n\n// Calculate contrast ratio\nvariable ratio: Number = (lighter + 0.05) / (darker + 0.05);\n\nreturn ratio;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/"
-      ],
-      "slug": "contrast_ratio"
-    },
-    {
-      "name": "cooler",
-      "type": "function",
-      "description": "Shifts a color's hue towards cool colors (blue, ~260° in OKLCH). The amount parameter controls how much to shift, from 0 (no change) to 1 (fully cool). Preserves lightness and chroma.",
-      "keyword": "cooler",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to cool",
-                "type": "color"
-              },
-              {
-                "description": "Amount to shift (0-1), default 0.25",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color shifted towards cool hues"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// cooler: Shift hue towards cool colors\n//\n// Cool colors are centered around blue (~260° in OKLCH).\n// The function interpolates the hue towards this target via\n// the shortest angular path on the hue wheel.\n//\n// Parameters:\n//   color  - Input color\n//   amount - Shift amount (0 = no change, 1 = fully cool), default 0.25\n//\n// Preserves lightness and chroma.\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable amount: Number = 0.25;\n\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Cool hue target (blue in OKLCH is around 260°)\nvariable cool_hue: Number = 260;\n\n// Calculate shortest path hue difference\nvariable hue_diff: Number = cool_hue - color.h;\n\n// Wrap to shortest path\nif (hue_diff > 180) [ hue_diff = hue_diff - 360; ];\nif (hue_diff < -180) [ hue_diff = hue_diff + 360; ];\n\n// Apply interpolation\nvariable new_hue: Number = color.h + (hue_diff * amount);\n\n// Normalize to 0-360\nif (new_hue < 0) [ new_hue = new_hue + 360; ];\nif (new_hue >= 360) [ new_hue = new_hue - 360; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = new_hue;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Make orange cooler",
-          "input": [
-            "#ff6600",
-            0.5
-          ],
-          "output": "Orange shifted towards neutral"
-        }
-      ],
-      "slug": "cooler"
-    },
-    {
-      "name": "Darken",
-      "type": "function",
-      "description": "Makes a color darker by decreasing its lightness in OKLab space. Amount is 0-1 where 0.25 = 25% darker.",
-      "keyword": "darken",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to darken"
-          },
-          "amount": {
-            "type": "number",
-            "description": "Amount to darken (0-1). Default is 0.25"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// darken: Decrease lightness proportionally towards black\n// Amount: 0-1 where 0.25 means 25% closer to black\n//\n// Algorithm: L' = L * (1 - amount)\n// This ensures we approach black (L=0) proportionally.\n//\n// Input:  Any color space (converted to OKLab internally)\n// Output: OKLCH (working space)\n// To get sRGB: darken(color, 0.25).to.srgb()\n\nvariable input: List = {input};\nvariable color: Color.OKLab = input.get(0).to.oklab();\n\n// Default amount is 0.25 (25%)\nvariable amount: Number = 0.25;\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Calculate new lightness (move toward 0)\nvariable current_l: Number = color.l;\nvariable new_l: Number = current_l * (1 - amount);\n\n// Clamp to valid range\nif (new_l < 0) [ new_l = 0; ];\n\n// Create output in OKLab, return as OKLCH (working space)\nvariable result: Color.OKLab;\nresult.l = new_l;\nresult.a = color.a;\nresult.b = color.b;\n\nreturn result.to.oklch();"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "darken"
-    },
-    {
-      "name": "Delta E 2000",
-      "type": "function",
-      "description": "Calculates perceptual color difference using CIEDE2000 (ΔE00), the CIE-recommended color difference formula. More accurate than CIE76 for small differences. Industry standard for color quality control. Uses parametric weighting factors kL, kC, kH (all default to 1).",
-      "keyword": "delta_e_2000",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color (reference)"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color (sample)"
-          },
-          "kL": {
-            "type": "number",
-            "description": "Lightness weight (default 1)"
-          },
-          "kC": {
-            "type": "number",
-            "description": "Chroma weight (default 1)"
-          },
-          "kH": {
-            "type": "number",
-            "description": "Hue weight (default 1)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// CIEDE2000 Color Difference Formula (ΔE00)\n// Reference: CIE 142-2001 (Technical Report)\n// Reference: Color.js deltaE2000 implementation\n// Reference: Sharma, Wu, Dalal \"The CIEDE2000 Color-Difference Formula\" (2005)\n//\n// This is the CIE-recommended color difference formula, providing\n// better correlation with visual perception than CIE76 or CIE94.\n//\n// Parametric factors (kL, kC, kH):\n// - All default to 1.0 for reference conditions\n// - kL can be increased for lightness texture/noise\n// - kC can be increased for chroma noise\n//\n// Interpretation (approximate):\n//   0.0        - Identical colors\n//   < 1.0      - Not perceptible by human eye\n//   1.0 - 2.0  - Perceptible through close observation\n//   2.0 - 10.0 - Perceptible at a glance\n//   > 10.0     - Colors are obviously different\n\nvariable input: List = {input};\n\n// Convert both colors to CIE Lab\nvariable color1: Color.Lab = input.get(0).to.lab();\nvariable color2: Color.Lab = input.get(1).to.lab();\n\n// Get parametric weighting factors (default to 1)\nvariable k_l: Number = 1;\nvariable k_c: Number = 1;\nvariable k_h: Number = 1;\nif (input.length() > 2) [ k_l = input.get(2); ];\nif (input.length() > 3) [ k_c = input.get(3); ];\nif (input.length() > 4) [ k_h = input.get(4); ];\n\n// Constants\nvariable pi: Number = pi();\nvariable r2d: Number = 180 / pi;\nvariable d2r: Number = pi / 180;\nvariable g_factor: Number = 6103515625; // 25^7\nvariable e: Number = 2.718281828459045; // Euler's number\n\n// Get Lab values\nvariable l1: Number = color1.l;\nvariable a1: Number = color1.a;\nvariable b1: Number = color1.b;\n\nvariable l2: Number = color2.l;\nvariable a2: Number = color2.a;\nvariable b2: Number = color2.b;\n\n// Calculate C* (chroma) for both colors\nvariable c1: Number = sqrt(a1 * a1 + b1 * b1);\nvariable c2: Number = sqrt(a2 * a2 + b2 * b2);\n\n// Ensure non-negative chroma\nif (c1 < 0) [ c1 = 0; ];\nif (c2 < 0) [ c2 = 0; ];\n\n// Mean chroma\nvariable c_bar: Number = (c1 + c2) / 2;\n\n// Calculate G (a-axis asymmetry factor)\nvariable c7: Number = c_bar * c_bar * c_bar * c_bar * c_bar * c_bar * c_bar;\nvariable g: Number = 0.5 * (1 - sqrt(c7 / (c7 + g_factor)));\n\n// Scale a* values by asymmetry factor\nvariable a_prime1: Number = (1 + g) * a1;\nvariable a_prime2: Number = (1 + g) * a2;\n\n// Calculate C' from scaled a' and original b\nvariable c_prime1: Number = sqrt(a_prime1 * a_prime1 + b1 * b1);\nvariable c_prime2: Number = sqrt(a_prime2 * a_prime2 + b2 * b2);\n\n// Calculate h' (hue angles in degrees)\nvariable h1: Number = 0;\nif (a_prime1 != 0) [ h1 = atan2(b1, a_prime1); ];\nif (b1 != 0) [ h1 = atan2(b1, a_prime1); ];\nif (a_prime1 == 0) [\n    if (b1 == 0) [ h1 = 0; ] else [ h1 = atan2(b1, a_prime1); ];\n];\nh1 = h1 * r2d;\nif (h1 < 0) [ h1 = h1 + 360; ];\n\nvariable h2: Number = 0;\nif (a_prime2 != 0) [ h2 = atan2(b2, a_prime2); ];\nif (b2 != 0) [ h2 = atan2(b2, a_prime2); ];\nif (a_prime2 == 0) [\n    if (b2 == 0) [ h2 = 0; ] else [ h2 = atan2(b2, a_prime2); ];\n];\nh2 = h2 * r2d;\nif (h2 < 0) [ h2 = h2 + 360; ];\n\n// Lightness and Chroma differences\nvariable delta_l: Number = l2 - l1;\nvariable delta_c: Number = c_prime2 - c_prime1;\n\n// Hue difference (getting the sign correct)\nvariable h_diff: Number = h2 - h1;\nvariable h_sum: Number = h1 + h2;\nvariable h_abs: Number = h_diff;\nif (h_abs < 0) [ h_abs = 0 - h_abs; ];\n\nvariable delta_h: Number = 0;\nvariable c_product: Number = c_prime1 * c_prime2;\n\nif (c_product == 0) [\n    delta_h = 0;\n] else [\n    if (h_abs <= 180) [\n        delta_h = h_diff;\n    ] else [\n        if (h_diff > 180) [\n            delta_h = h_diff - 360;\n        ] else [\n            if (h_diff < -180) [\n                delta_h = h_diff + 360;\n            ] else [\n                delta_h = h_diff;\n            ];\n        ];\n    ];\n];\n\n// Weighted hue difference (ΔH')\nvariable delta_h_prime: Number = 2 * sqrt(c_prime2 * c_prime1) * sin(delta_h * d2r / 2);\n\n// Mean lightness and chroma\nvariable l_bar: Number = (l1 + l2) / 2;\nvariable c_bar_prime: Number = (c_prime1 + c_prime2) / 2;\nvariable c_bar_prime7: Number = c_bar_prime * c_bar_prime * c_bar_prime * c_bar_prime * c_bar_prime * c_bar_prime * c_bar_prime;\n\n// Mean hue (handling the 0/360 wraparound)\nvariable h_bar: Number = 0;\nif (c_product == 0) [\n    h_bar = h_sum;\n] else [\n    if (h_abs <= 180) [\n        h_bar = h_sum / 2;\n    ] else [\n        if (h_sum < 360) [\n            h_bar = (h_sum + 360) / 2;\n        ] else [\n            h_bar = (h_sum - 360) / 2;\n        ];\n    ];\n];\n\n// SL - Lightness crispening factor (assumes L=50 background)\nvariable l_bar_minus_50: Number = l_bar - 50;\nvariable l_sq: Number = l_bar_minus_50 * l_bar_minus_50;\nvariable s_l: Number = 1 + (0.015 * l_sq) / sqrt(20 + l_sq);\n\n// SC - Chroma factor\nvariable s_c: Number = 1 + 0.045 * c_bar_prime;\n\n// T - Cross term for blue non-linearity\nvariable t: Number = 1;\nt = t - 0.17 * cos((h_bar - 30) * d2r);\nt = t + 0.24 * cos(2 * h_bar * d2r);\nt = t + 0.32 * cos((3 * h_bar + 6) * d2r);\nt = t - 0.20 * cos((4 * h_bar - 63) * d2r);\n\n// SH - Hue factor\nvariable s_h: Number = 1 + 0.015 * c_bar_prime * t;\n\n// RT - Hue rotation term (for blue region 225-315 degrees)\nvariable h_bar_minus_275: Number = h_bar - 275;\nvariable exp_arg: Number = -1 * (h_bar_minus_275 / 25) * (h_bar_minus_275 / 25);\nvariable delta_theta: Number = 30 * pow(e, exp_arg);\nvariable r_c: Number = 2 * sqrt(c_bar_prime7 / (c_bar_prime7 + g_factor));\nvariable r_t: Number = -1 * sin(2 * delta_theta * d2r) * r_c;\n\n// Calculate final ΔE00\nvariable term_l: Number = delta_l / (k_l * s_l);\nvariable term_c: Number = delta_c / (k_c * s_c);\nvariable term_h: Number = delta_h_prime / (k_h * s_h);\n\nvariable de: Number = term_l * term_l + term_c * term_c + term_h * term_h;\nde = de + r_t * (delta_c / (k_c * s_c)) * (delta_h_prime / (k_h * s_h));\n\nvariable result: Number = sqrt(de);\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/lab-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/lch-color/0/"
-      ],
-      "slug": "delta_e_2000"
-    },
-    {
-      "name": "Delta E 76",
-      "type": "function",
-      "description": "Calculates color difference using CIE76 formula (ΔE*ab). Simple Euclidean distance in CIE Lab space. Less accurate than Delta E 2000 for small differences, but faster and adequate for many applications. Formula: sqrt((L1-L2)² + (a1-a2)² + (b1-b2)²).",
-      "keyword": "delta_e_76",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color (reference)"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color (sample)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Delta E 76 (CIE76 Color Difference)\n// Reference: CIE Publication 15.2 (1986)\n// Reference: ASTM E308 Standard\n//\n// The original CIE color difference formula from 1976.\n// Simple Euclidean distance in CIE Lab space.\n//\n// Formula: ΔE*ab = sqrt((L1-L2)² + (a1-a2)² + (b1-b2)²)\n//\n// Interpretation:\n//   0 - 1:     Not perceptible by human eye\n//   1 - 2:     Perceptible through close observation\n//   2 - 10:    Perceptible at a glance\n//   11 - 49:   Colors are more similar than opposite\n//   100+:      Colors are exact opposite\n//\n// Limitations:\n// - Lab is not perfectly perceptually uniform\n// - Overestimates differences for saturated colors\n// - Use Delta E 2000 for critical color matching\n\nvariable input: List = {input};\nvariable color1: Color.Lab = input.get(0).to.lab();\nvariable color2: Color.Lab = input.get(1).to.lab();\n\n// Get Lab components\nvariable l1: Number = color1.l;\nvariable a1: Number = color1.a;\nvariable b1: Number = color1.b;\n\nvariable l2: Number = color2.l;\nvariable a2: Number = color2.a;\nvariable b2: Number = color2.b;\n\n// Calculate differences\nvariable delta_l: Number = l1 - l2;\nvariable delta_a: Number = a1 - a2;\nvariable delta_b: Number = b1 - b2;\n\n// Euclidean distance\nvariable sum_squares: Number = delta_l * delta_l + delta_a * delta_a + delta_b * delta_b;\nvariable result: Number = sqrt(sum_squares);\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/lab-color/0/"
-      ],
-      "slug": "delta_e_76"
-    },
-    {
-      "name": "Delta E OK",
-      "type": "function",
-      "description": "Calculates perceptual color difference using the OKLab color space (ΔE_OK). This is the Euclidean distance in OKLab space, providing excellent perceptual uniformity. Values: 0 = identical, <0.02 = imperceptible, <0.05 = very close, <0.1 = noticeable, >0.5 = very different.",
-      "keyword": "delta_e_ok",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color (reference)"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color (sample)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Delta E OK (ΔE_OK)\n// Perceptual color difference in OKLab space\n// Reference: Björn Ottosson's OKLab specification\n// Reference: Color.js deltaEOK implementation\n//\n// This is simply the Euclidean distance in OKLab space.\n// OKLab is designed to be perceptually uniform, making this\n// a reliable measure of perceived color difference.\n//\n// Interpretation:\n//   0.00       - Identical colors\n//   < 0.02     - Imperceptible difference (JND threshold)\n//   < 0.05     - Very close colors\n//   < 0.1      - Noticeable but small difference\n//   0.1 - 0.5  - Moderate difference\n//   > 0.5      - Very different colors\n//\n// Formula: sqrt((L1-L2)² + (a1-a2)² + (b1-b2)²)\n\nvariable input: List = {input};\nvariable color1: Color.OKLab = input.get(0).to.oklab();\nvariable color2: Color.OKLab = input.get(1).to.oklab();\n\n// Get OKLab components\nvariable l1: Number = color1.l;\nvariable a1: Number = color1.a;\nvariable b1: Number = color1.b;\n\nvariable l2: Number = color2.l;\nvariable a2: Number = color2.a;\nvariable b2: Number = color2.b;\n\n// Calculate differences\nvariable delta_l: Number = l1 - l2;\nvariable delta_a: Number = a1 - a2;\nvariable delta_b: Number = b1 - b2;\n\n// Calculate Euclidean distance (sqrt of sum of squares)\nvariable sum_squares: Number = delta_l * delta_l + delta_a * delta_a + delta_b * delta_b;\nvariable result: Number = sqrt(sum_squares);\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/"
-      ],
-      "slug": "delta_e_ok"
-    },
-    {
-      "name": "Desaturate",
-      "type": "function",
-      "description": "Decreases color saturation by reducing chroma in OKLCH space. Amount is 0-1 where 0.25 = 25% less saturated.",
-      "keyword": "desaturate",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to desaturate"
-          },
-          "amount": {
-            "type": "number",
-            "description": "Amount to desaturate (0-1). Default is 0.25"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Desaturate a color by decreasing its OKLCH chroma\n// Amount: 0-1 where 0.25 means 25% decrease, 1.0 = full grayscale\n//\n// Algorithm: C' = C * (1 - amount)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Default amount is 0.25 (25%)\nvariable amount: Number = 0.25;\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Calculate new chroma\nvariable current_c: Number = color.c;\nvariable new_c: Number = current_c * (1 - amount);\n\n// Clamp to valid range\nif (new_c < 0) [ new_c = 0; ];\n\n// Create output in OKLCH, return as sRGB\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "desaturate"
-    },
-    {
-      "name": "Distributed",
-      "type": "function",
-      "description": "Creates evenly distributed colors around the OKLCH hue wheel. Perfect for categorical data where each category needs a distinct, visually balanced color.",
-      "keyword": "distributed",
-      "input": {
-        "type": "object",
-        "properties": {
-          "count": {
-            "type": "number",
-            "description": "Number of colors to generate. Default is 6"
-          },
-          "lightness": {
-            "type": "number",
-            "description": "Lightness for all colors (0-1). Default is 0.7"
-          },
-          "chroma": {
-            "type": "number",
-            "description": "Chroma/saturation for all colors (0-0.4). Default is 0.15"
-          },
-          "start_hue": {
-            "type": "number",
-            "description": "Starting hue angle (0-360). Default is 30 (orange)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Create evenly distributed categorical colors using OKLCH\n// Colors are spaced equally around the hue wheel\n//\n// Ideal for: pie charts, bar charts, legends, category labels\n// Uses golden angle offset for better distinction with many colors\n\nvariable input: List = {input};\n\n// Default count is 6\nvariable count: Number = 6;\nif (input.length() > 0) [\n    count = input.get(0);\n];\n\n// Default lightness is 0.7 (good for both light/dark backgrounds)\nvariable lightness: Number = 0.7;\nif (input.length() > 1) [\n    lightness = input.get(1);\n];\n\n// Default chroma is 0.15 (vivid but not overwhelming)\nvariable chroma: Number = 0.15;\nif (input.length() > 2) [\n    chroma = input.get(2);\n];\n\n// Default start hue is 30 (orange - visually distinct starting point)\nvariable start_hue: Number = 30;\nif (input.length() > 3) [\n    start_hue = input.get(3);\n];\n\n// Calculate hue step (360° / count for even distribution)\nvariable hue_step: Number = 360 / count;\n\nvariable result: List;\nvariable i: Number = 0;\nvariable current_hue: Number = 0;\nvariable color: Color.OKLCH;\n\nwhile (i < count) [\n    current_hue = start_hue + i * hue_step;\n    if (current_hue >= 360) [ current_hue = current_hue - 360; ];\n    \n    color.l = lightness;\n    color.c = chroma;\n    color.h = current_hue;\n    \n    result = result, color.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "distributed"
-    },
-    {
-      "name": "Diverging",
-      "type": "function",
-      "description": "Creates a diverging color palette for heatmaps. Goes from color1 through a neutral midpoint to color2. Perfect for data that diverges from a center value (e.g., -1 to 0 to +1).",
-      "keyword": "diverging",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "Color for negative/low end (e.g., blue)"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Color for positive/high end (e.g., red)"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of steps (should be odd for clear midpoint). Default is 9"
-          },
-          "neutral": {
-            "type": "number",
-            "description": "Lightness of neutral midpoint (0-1). Default is 0.95 (near white)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Create a diverging color palette for data visualization\n// Goes: color1 → neutral → color2\n//\n// Ideal for: heatmaps, correlation matrices, deviation from mean\n// Example: blue → white → red for temperature anomalies\n\nvariable input: List = {input};\nvariable color1: Color.OKLCH = input.get(0).to.oklch();\nvariable color2: Color.OKLCH = input.get(1).to.oklch();\n\n// Default count is 9 (gives clear midpoint at index 4)\nvariable count: Number = 9;\nif (input.length() > 2) [\n    count = input.get(2);\n];\n\n// Default neutral lightness is 0.95 (near white)\nvariable neutral_l: Number = 0.95;\nif (input.length() > 3) [\n    neutral_l = input.get(3);\n];\n\n// Calculate midpoint index\nvariable mid: Number = (count - 1) / 2;\n\nvariable result: List;\nvariable i: Number = 0;\nvariable t: Number = 0;\nvariable step_color: Color.OKLCH;\n\nwhile (i < count) [\n    if (i < mid) [\n        // First half: color1 → neutral\n        t = i / mid;\n        step_color.l = color1.l + (neutral_l - color1.l) * t;\n        step_color.c = color1.c * (1 - t);\n        step_color.h = color1.h;\n    ] else [\n        if (i == mid) [\n            // Midpoint: neutral (achromatic)\n            step_color.l = neutral_l;\n            step_color.c = 0;\n            step_color.h = 0;\n        ] else [\n            // Second half: neutral → color2\n            t = (i - mid) / mid;\n            step_color.l = neutral_l + (color2.l - neutral_l) * t;\n            step_color.c = color2.c * t;\n            step_color.h = color2.h;\n        ];\n    ];\n    \n    result = result, step_color.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "diverging"
-    },
-    {
-      "name": "Grayscale",
-      "type": "function",
-      "description": "Converts a color to grayscale by removing all chroma in OKLCH space. Preserves perceptual lightness.",
-      "keyword": "grayscale",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to convert to grayscale"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Convert a color to grayscale by setting OKLCH chroma to 0\n// This preserves perceptual lightness (unlike simple RGB averaging)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Create grayscale by removing chroma\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = 0;\nresult.h = 0;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "grayscale"
-    },
-    {
-      "name": "harmonize",
-      "type": "function",
-      "description": "Harmonizes a color by shifting its hue toward a source color. Inspired by Material Design 3's color harmonization algorithm. This creates visual cohesion in design systems by making colors feel related while preserving their identity. The amount parameter controls how much the hue shifts (0 = no change, 1 = full shift to source hue).",
-      "keyword": "harmonize",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to harmonize",
-                "type": "color"
-              },
-              {
-                "description": "Source color (hue target)",
-                "type": "color"
-              },
-              {
-                "description": "Amount of harmonization (0-1, default 0.5)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 3
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Harmonized color with hue shifted toward source"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// harmonize: Shift hue towards a source color for visual harmony\n// Reference: Material Design 3 Color System\n// Reference: https://m3.material.io/styles/color/dynamic-color\n//\n// Shifts the input color's hue towards a source color by a specified\n// amount, creating a harmonized palette. Uses OKLCH for perceptually\n// uniform hue interpolation via the shortest angular path.\n//\n// Parameters:\n//   color  - Color to harmonize\n//   source - Target hue source\n//   amount - Shift amount (0 = no change, 1 = match source), default 0.5\n//\n// Input:  Any color space (converted to OKLCH internally)\n// Output: OKLCH (working space)\n// To get sRGB: harmonize(color, source, 0.5).to.srgb()\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable source: Color.OKLCH = input.get(1).to.oklch();\n\n// Default harmonization amount (0.5 = 50% shift)\nvariable amount: Number = 0.5;\nif (input.length() > 2) [\n    amount = input.get(2);\n];\n\n// Get hues\nvariable color_hue: Number = color.h;\nvariable source_hue: Number = source.h;\n\n// Calculate shortest path around the hue circle\nvariable diff: Number = source_hue - color_hue;\n\n// Normalize to -180 to 180 range for shortest path\nif (diff > 180) [\n    diff = diff - 360;\n];\nif (diff < -180) [\n    diff = diff + 360;\n];\n\n// Apply harmonization: shift hue by amount * difference\nvariable new_hue: Number = color_hue + (diff * amount);\n\n// Normalize hue to 0-360\nif (new_hue < 0) [\n    new_hue = new_hue + 360;\n];\nif (new_hue >= 360) [\n    new_hue = new_hue - 360;\n];\n\n// Create result with shifted hue, preserving lightness and chroma\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = new_hue;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Harmonize red toward blue",
-          "input": [
-            "#ff0000",
-            "#0000ff",
-            0.3
-          ],
-          "output": "Color with hue shifted toward blue"
-        },
-        {
-          "description": "Harmonize green toward brand color",
-          "input": [
-            "#00ff00",
-            "#6750a4"
-          ],
-          "output": "Green shifted toward purple brand"
-        }
-      ],
-      "slug": "harmonize"
-    },
-    {
-      "name": "hue",
-      "type": "function",
-      "description": "Extracts the hue angle from any color using OKLCH. Returns a value from 0 to 360 degrees representing the color's position on the hue wheel. Hue in OKLCH is perceptually uniform, meaning equal angular steps produce equally perceived hue changes. Essential for color harmony calculations and palette generation.",
-      "keyword": "hue",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to extract hue from",
-                "type": "color"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 1
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "number",
-        "description": "Hue angle (0-360 degrees)"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// hue: Extract hue angle from a color\n// Reference: OKLCH Color Space (Björn Ottosson)\n// Reference: https://bottosson.github.io/posts/oklab/\n//\n// Returns the H component from OKLCH, representing the\n// perceptually uniform hue angle. Range: 0-360 degrees.\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\nreturn color.h;"
-      },
-      "examples": [
-        {
-          "description": "Red has hue around 30° in OKLCH",
-          "input": [
-            "#ff0000"
-          ],
-          "output": 29
-        },
-        {
-          "description": "Cyan has hue around 195°",
-          "input": [
-            "#00ffff"
-          ],
-          "output": 195
-        }
-      ],
-      "slug": "hue"
-    },
-    {
-      "name": "Hue Difference",
-      "type": "function",
-      "description": "Calculates the angular difference between two color hues. Returns the shortest path around the hue circle (0-180°). Useful for determining how different two colors are in terms of hue alone, ignoring lightness and chroma.",
-      "keyword": "hue_difference",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Hue Difference\n// Calculates angular hue difference using shortest path\n//\n// The hue circle wraps at 360°, so we need to find\n// the shortest angular distance between two hues.\n//\n// Examples:\n//   hue_diff(350°, 10°) = 20° (not 340°)\n//   hue_diff(0°, 180°) = 180° (maximum difference)\n//   hue_diff(90°, 90°) = 0° (same hue)\n//\n// Returns value in range [0, 180]\n\nvariable input: List = {input};\nvariable color1: Color.OKLCH = input.get(0).to.oklch();\nvariable color2: Color.OKLCH = input.get(1).to.oklch();\n\n// Get hue values\nvariable h1: Number = color1.h;\nvariable h2: Number = color2.h;\n\n// Normalize to 0-360\nif (h1 < 0) [ h1 = h1 + 360; ];\nif (h1 >= 360) [ h1 = h1 - 360; ];\nif (h2 < 0) [ h2 = h2 + 360; ];\nif (h2 >= 360) [ h2 = h2 - 360; ];\n\n// Calculate raw difference\nvariable diff: Number = h1 - h2;\n\n// Make positive\nif (diff < 0) [\n    diff = 0 - diff;\n];\n\n// Take shortest path around circle\nif (diff > 180) [\n    diff = 360 - diff;\n];\n\nreturn diff;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "slug": "hue_difference"
-    },
-    {
-      "name": "In Gamut",
-      "type": "function",
-      "description": "Checks if a color is within the sRGB gamut. Returns true if all RGB components are in [0,1] range, false otherwise. Useful for checking if colors from wider gamuts (P3, OKLab) can be displayed on standard monitors.",
-      "keyword": "in_gamut",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Color to check"
-          },
-          "epsilon": {
-            "type": "number",
-            "description": "Tolerance for near-gamut colors (default 0.000075)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// In Gamut Check\n// Checks if a color is within the sRGB gamut\n// Reference: Color.js inGamut implementation\n//\n// sRGB gamut is defined by all RGB components being in [0, 1]\n// This is critical for determining if colors can be displayed\n// on standard monitors without clipping.\n//\n// An epsilon tolerance is used to handle floating-point precision\n// issues near the gamut boundary.\n\nvariable input: List = {input};\nvariable color: Color.SRGB = input.get(0).to.srgb();\n\n// Default epsilon from Color.js\nvariable epsilon: Number = 0.000075;\nif (input.length() > 1) [\n    epsilon = input.get(1);\n];\n\n// Get RGB values\nvariable r: Number = color.r;\nvariable g: Number = color.g;\nvariable b: Number = color.b;\n\n// Check if within gamut bounds with epsilon tolerance\nvariable min_bound: Number = 0 - epsilon;\nvariable max_bound: Number = 1 + epsilon;\n\n// All channels must be within bounds\nvariable r_in: Boolean = r >= min_bound;\nif (r_in) [ r_in = r <= max_bound; ];\n\nvariable g_in: Boolean = g >= min_bound;\nif (g_in) [ g_in = g <= max_bound; ];\n\nvariable b_in: Boolean = b >= min_bound;\nif (b_in) [ b_in = b <= max_bound; ];\n\n// Return true only if all channels are in gamut\nvariable result: Boolean = false;\nif (r_in) [\n    if (g_in) [\n        if (b_in) [\n            result = true;\n        ];\n    ];\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "in_gamut"
-    },
-    {
-      "name": "interpolate",
-      "type": "function",
-      "description": "Interpolates between two colors at a given position in perceptual OKLCH space. Position of 0 returns the first color, 1 returns the second color, 0.5 returns the midpoint. Uses shortest-path hue interpolation for natural color transitions.",
-      "keyword": "interpolate",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Start color",
-                "type": "color"
-              },
-              {
-                "description": "End color",
-                "type": "color"
-              },
-              {
-                "description": "Position (0-1, default 0.5)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 3
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Interpolated color"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// interpolate: Blend between two colors in perceptual space\n// Reference: CSS Color Level 4 Color Interpolation\n// Reference: https://www.w3.org/TR/css-color-4/#interpolation\n//\n// Performs linear interpolation in OKLCH space with shortest-path\n// hue interpolation. OKLCH provides perceptually uniform results.\n//\n// Parameters:\n//   start - First color (t=0)\n//   end   - Second color (t=1)\n//   t     - Interpolation factor [0, 1], default 0.5\n//\n// Input:  Any color space (converted to OKLCH internally)\n// Output: OKLCH (working space)\n// To get sRGB: interpolate(start, end, 0.5).to.srgb()\n\nvariable input: List = {input};\nvariable start: Color.OKLCH = input.get(0).to.oklch();\nvariable end: Color.OKLCH = input.get(1).to.oklch();\n\n// Default to midpoint\nvariable t: Number = 0.5;\nif (input.length() > 2) [\n    t = input.get(2);\n];\n\n// Clamp t to valid range\nif (t < 0) [ t = 0; ];\nif (t > 1) [ t = 1; ];\n\n// Interpolate lightness and chroma linearly\nvariable result_l: Number = start.l + (end.l - start.l) * t;\nvariable result_c: Number = start.c + (end.c - start.c) * t;\n\n// Interpolate hue using shortest path\nvariable h1: Number = start.h;\nvariable h2: Number = end.h;\nvariable delta_h: Number = h2 - h1;\n\n// Normalize to shortest path around the circle\nif (delta_h > 180) [\n    delta_h = delta_h - 360;\n];\nif (delta_h < -180) [\n    delta_h = delta_h + 360;\n];\n\nvariable result_h: Number = h1 + delta_h * t;\n\n// Normalize result hue to 0-360\nif (result_h < 0) [ result_h = result_h + 360; ];\nif (result_h >= 360) [ result_h = result_h - 360; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = result_l;\nresult.c = result_c;\nresult.h = result_h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Midpoint between red and blue",
-          "input": [
-            "#ff0000",
-            "#0000ff",
-            0.5
-          ],
-          "output": "Purple-ish color in OKLCH"
-        },
-        {
-          "description": "Quarter way from black to white",
-          "input": [
-            "#000000",
-            "#ffffff",
-            0.25
-          ],
-          "output": "Dark gray"
-        }
-      ],
-      "slug": "interpolate"
-    },
-    {
-      "name": "Invert Color",
-      "type": "function",
-      "description": "Inverts a color by inverting each RGB channel (R' = 255 - R, G' = 255 - G, B' = 255 - B).",
-      "keyword": "invert",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to invert."
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Invert Color Function\n// Returns the inverse/negative of a color by subtracting each RGB channel from 255\n//\n// Algorithm:\n//   R' = 255 - R\n//   G' = 255 - G  \n//   B' = 255 - B\n//\n// Use cases:\n//   - Creating negative images\n//   - High contrast accessibility variants\n//   - Artistic color effects\n//\n// Input: Any color (converted to RGB internally)\n// Output: Color.Rgb with inverted channels\n\nvariable input: List = {input};\n\n// Convert input to RGB (0-255 range)\nvariable rgb_color: Color.Rgb = input.get(0).to.rgb();\n\n// Invert each channel by subtracting from 255\nvariable inverted_r: Number = 255 - rgb_color.r;\nvariable inverted_g: Number = 255 - rgb_color.g;\nvariable inverted_b: Number = 255 - rgb_color.b;\n\n// Create and return the inverted color\nvariable inverted_color: Color.Rgb = rgb(inverted_r, inverted_g, inverted_b);\nreturn inverted_color;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/rgb-color/0/"
-      ],
-      "slug": "invert"
-    },
-    {
-      "name": "Is Cool",
-      "type": "function",
-      "description": "Checks if a color is perceptually cool. Cool colors have hues in the green-blue-purple range (roughly 130-320° in OKLCH). Returns true for cool colors (green, cyan, blue, purple), false for warm colors. Achromatic colors are considered neutral/cool.",
-      "keyword": "is_cool",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Color to check"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Is Cool Color\n// Determines if a color is perceptually cool\n//\n// Cool colors are associated with:\n// - Water, ice, sky\n// - Calm, professional, trustworthy feelings\n// - Receding visual perception (appear further away)\n//\n// OKLCH hue ranges:\n// - Cool: 130-320° (yellow-green through purple)\n// - Includes: green, cyan, blue, purple\n//\n// Achromatic colors (low chroma) are considered cool/neutral\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Get hue and chroma\nvariable h: Number = color.h;\nvariable c: Number = color.c;\n\n// Achromatic colors (very low chroma) are considered cool/neutral\nif (c < 0.02) [\n    return true;\n];\n\n// Normalize hue to 0-360\nif (h < 0) [ h = h + 360; ];\nif (h >= 360) [ h = h - 360; ];\n\n// Cool hue range: 130-320° (green through purple)\nvariable is_cool: Boolean = false;\n\nif (h > 130) [\n    if (h < 320) [\n        is_cool = true;\n    ];\n];\n\nreturn is_cool;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "slug": "is_cool"
-    },
-    {
-      "name": "Is Dark",
-      "type": "function",
-      "description": "Returns true if a color is perceptually dark (lightness <= threshold). Uses OKLCH lightness for perceptual accuracy. Default threshold is 0.6.",
-      "keyword": "is_dark",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to check"
-          },
-          "threshold": {
-            "type": "number",
-            "description": "Lightness threshold (0-1). Default is 0.6"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Check if a color is perceptually dark\n// Uses OKLCH lightness for accurate perception matching\n//\n// Returns: true if L <= threshold, false otherwise\n// Default threshold: 0.6 (slightly above middle)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\nvariable threshold: Number = 0.6;\nif (input.length() > 1) [\n    threshold = input.get(1);\n];\n\nreturn color.l <= threshold;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "slug": "is_dark"
-    },
-    {
-      "name": "Is Light",
-      "type": "function",
-      "description": "Returns true if a color is perceptually light (lightness > threshold). Uses OKLCH lightness for perceptual accuracy. Default threshold is 0.6.",
-      "keyword": "is_light",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to check"
-          },
-          "threshold": {
-            "type": "number",
-            "description": "Lightness threshold (0-1). Default is 0.6"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Check if a color is perceptually light\n// Uses OKLCH lightness for accurate perception matching\n//\n// Returns: true if L > threshold, false otherwise\n// Default threshold: 0.6 (slightly above middle)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\nvariable threshold: Number = 0.6;\nif (input.length() > 1) [\n    threshold = input.get(1);\n];\n\nreturn color.l > threshold;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "slug": "is_light"
-    },
-    {
-      "name": "is_neutral",
-      "type": "function",
-      "description": "Determines if a color is achromatic (neutral/gray). Uses OKLCH chroma value - colors with very low chroma are considered neutral regardless of their hue. Default threshold of 0.02 allows for near-neutral colors that appear gray to human observers.",
-      "keyword": "is_neutral",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to test",
-                "type": "color"
-              },
-              {
-                "description": "Chroma threshold (default 0.02). Lower = stricter.",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "boolean",
-        "description": "True if color is achromatic/neutral"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// is_neutral: Check if a color is achromatic (gray)\n// Uses OKLCH chroma - low chroma means neutral\n// Threshold of 0.02 allows for near-neutral colors\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Default chroma threshold\nvariable threshold: Number = 0.02;\nif (input.length() > 1) [\n    threshold = input.get(1);\n];\n\n// Color is neutral if chroma is below threshold\nreturn color.c < threshold;"
-      },
-      "examples": [
-        {
-          "description": "Pure gray is neutral",
-          "input": [
-            "#808080"
-          ],
-          "output": true
-        },
-        {
-          "description": "Pure red is not neutral",
-          "input": [
-            "#ff0000"
-          ],
-          "output": false
-        },
-        {
-          "description": "Desaturated color may be neutral",
-          "input": [
-            "#7a7a7c"
-          ],
-          "output": true
-        }
-      ],
-      "slug": "is_neutral"
-    },
-    {
-      "name": "Is Warm",
-      "type": "function",
-      "description": "Checks if a color is perceptually warm. Uses OKLCH color space where warm colors have hues in the red-yellow range (roughly 0-130° and 320-360°). Returns true for warm colors (red, orange, yellow), false for cool colors (green, cyan, blue, purple). Achromatic colors are considered neutral/cool.",
-      "keyword": "is_warm",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Color to check"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Is Warm Color\n// Determines if a color is perceptually warm or cool\n//\n// Color Temperature Psychology:\n// - Warm colors: Red, orange, yellow (associated with fire, sun)\n// - Cool colors: Blue, green, purple (associated with water, ice)\n//\n// Hue ranges (in OKLCH/HSL degrees):\n// - Warm: roughly 0-90° (red through yellow) and 330-360° (red-magenta)\n// - Cool: roughly 90-330° (yellow-green through purple)\n//\n// Achromatic colors (low chroma) are considered neutral\n// and return false (lean towards cool for safety in accessibility)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Get hue and chroma\nvariable h: Number = color.h;\nvariable c: Number = color.c;\n\n// Achromatic colors (very low chroma) are neutral\n// Return false (cool) for these\nif (c < 0.02) [\n    return false;\n];\n\n// Normalize hue to 0-360\nif (h < 0) [ h = h + 360; ];\nif (h >= 360) [ h = h - 360; ];\n\n// OKLCH Warm hue ranges:\n// In OKLCH, hue angles differ from HSL:\n// - Red: ~29°\n// - Orange: ~53°\n// - Yellow: ~110°\n// - Yellow-green: ~130°\n// - Green: ~145°\n// - Cyan: ~195°\n// - Blue: ~265°\n// - Purple: ~300°\n// - Magenta: ~330°\n//\n// Warm colors: 0-130° (red through yellow-green) and 320-360° (magenta-red)\nvariable is_warm: Boolean = false;\n\n// Check 0-130 range (red through yellow to yellow-green)\nif (h >= 0) [\n    if (h <= 130) [\n        is_warm = true;\n    ];\n];\n\n// Check 320-360 range (magenta-red)\nif (h >= 320) [\n    if (h <= 360) [\n        is_warm = true;\n    ];\n];\n\nreturn is_warm;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "slug": "is_warm"
-    },
-    {
-      "name": "Lighten",
-      "type": "function",
-      "description": "Makes a color lighter by increasing its lightness in OKLab space. Amount is 0-1 where 0.25 = 25% lighter.",
-      "keyword": "lighten",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to lighten"
-          },
-          "amount": {
-            "type": "number",
-            "description": "Amount to lighten (0-1). Default is 0.25"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// lighten: Increase lightness proportionally towards white\n// Amount: 0-1 where 0.25 means 25% closer to white\n//\n// Algorithm: L' = L + (1 - L) * amount\n// This ensures we approach white (L=1) proportionally.\n//\n// Input:  Any color space (converted to OKLab internally)\n// Output: OKLCH (working space)\n// To get sRGB: lighten(color, 0.25).to.srgb()\n\nvariable input: List = {input};\nvariable color: Color.OKLab = input.get(0).to.oklab();\n\n// Default amount is 0.25 (25%)\nvariable amount: Number = 0.25;\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Calculate new lightness (move toward 1)\nvariable current_l: Number = color.l;\nvariable new_l: Number = current_l + (1 - current_l) * amount;\n\n// Clamp to valid range\nif (new_l > 1) [ new_l = 1; ];\n\n// Create output in OKLab, return as OKLCH (working space)\nvariable result: Color.OKLab;\nresult.l = new_l;\nresult.a = color.a;\nresult.b = color.b;\n\nreturn result.to.oklch();"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklab-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "lighten"
-    },
-    {
-      "name": "lightness",
-      "type": "function",
-      "description": "Extracts the perceptual lightness value from any color using OKLCH. Returns a value from 0 (black) to 1 (white). This is the 'L' in OKLCH, which is perceptually uniform - equal steps in L appear as equal steps in lightness to human vision. Essential for creating perceptually even color scales.",
-      "keyword": "lightness",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to extract lightness from",
-                "type": "color"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 1
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "number",
-        "description": "Perceptual lightness value (0-1)"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// lightness: Extract perceptual lightness from a color\n// Reference: OKLCH Color Space (Björn Ottosson)\n// Reference: https://bottosson.github.io/posts/oklab/\n//\n// Returns the L component from OKLCH, which represents\n// perceptually uniform lightness. Range: 0 (black) to 1 (white).\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\nreturn color.l;"
-      },
-      "examples": [
-        {
-          "description": "White has lightness 1",
-          "input": [
-            "#ffffff"
-          ],
-          "output": 1
-        },
-        {
-          "description": "Black has lightness 0",
-          "input": [
-            "#000000"
-          ],
-          "output": 0
-        },
-        {
-          "description": "Mid-gray has lightness ~0.6",
-          "input": [
-            "#808080"
-          ],
-          "output": 0.6
-        }
-      ],
-      "slug": "lightness"
-    },
-    {
-      "name": "Luminance",
-      "type": "function",
-      "description": "Returns the relative luminance of a color (0-1). Uses the WCAG formula based on linear sRGB. Useful for contrast calculations and accessibility.",
-      "keyword": "luminance",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to measure"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Get relative luminance of a color\n// Per WCAG 2.1: L = 0.2126*R + 0.7152*G + 0.0722*B (linear RGB)\n//\n// Returns: 0 (black) to 1 (white)\n// Used for contrast calculations\n\nvariable input: List = {input};\nvariable color: Color.LinearSRGB = input.get(0).to.linearsrgb();\n\nvariable lum: Number = 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;\n\nreturn lum;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/"
-      ],
-      "slug": "luminance"
-    },
-    {
-      "name": "Meets Contrast",
-      "type": "function",
-      "description": "Checks if two colors meet WCAG 2.1 contrast requirements. Returns true if contrast ratio meets the specified level: 'AA' (4.5:1 for normal text, 3:1 for large text), 'AAA' (7:1 for normal text, 4.5:1 for large text), or a custom ratio.",
-      "keyword": "meets_contrast",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color"
-          },
-          "threshold": {
-            "type": "number",
-            "description": "Minimum contrast ratio required (default: 4.5 for AA)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Meets Contrast (WCAG 2.1 Compliance Check)\n// Reference: WCAG 2.1 Success Criteria 1.4.3 and 1.4.6\n// Reference: https://www.w3.org/TR/WCAG21/#contrast-minimum\n//\n// WCAG 2.1 Contrast Levels:\n//   - Level AA (normal text):  4.5:1\n//   - Level AA (large text):   3:1\n//   - Level AAA (normal text): 7:1\n//   - Level AAA (large text):  4.5:1\n//\n// Large text is defined as:\n//   - 14pt (18.66px) bold\n//   - 18pt (24px) regular\n//\n// Returns true if the contrast ratio meets or exceeds the threshold.\n\nvariable input: List = {input};\nvariable color1: Color.LinearSRGB = input.get(0).to.linearsrgb();\nvariable color2: Color.LinearSRGB = input.get(1).to.linearsrgb();\n\n// Default threshold is 4.5 (WCAG AA for normal text)\nvariable threshold: Number = 4.5;\nif (input.length() > 2) [\n    threshold = input.get(2);\n];\n\n// Calculate relative luminance for each color\n// Formula: L = 0.2126 * R + 0.7152 * G + 0.0722 * B\nvariable lum1: Number = 0.2126 * color1.r + 0.7152 * color1.g + 0.0722 * color1.b;\nvariable lum2: Number = 0.2126 * color2.r + 0.7152 * color2.g + 0.0722 * color2.b;\n\n// Ensure non-negative luminance\nif (lum1 < 0) [ lum1 = 0; ];\nif (lum2 < 0) [ lum2 = 0; ];\n\n// Determine lighter and darker luminance\nvariable lighter: Number = lum1;\nvariable darker: Number = lum2;\nif (lum2 > lum1) [\n    lighter = lum2;\n    darker = lum1;\n];\n\n// Calculate contrast ratio: (L1 + 0.05) / (L2 + 0.05)\nvariable ratio: Number = (lighter + 0.05) / (darker + 0.05);\n\n// Return whether it meets the threshold\nreturn ratio >= threshold;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-linear-color/0/"
-      ],
-      "slug": "meets_contrast"
-    },
-    {
-      "name": "Mix",
-      "type": "function",
-      "description": "Blends two colors together in OKLCH space. Amount 0 = first color, 1 = second color, 0.5 = equal blend.",
-      "keyword": "mix",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "First color"
-          },
-          "color2": {
-            "type": "color",
-            "description": "Second color"
-          },
-          "amount": {
-            "type": "number",
-            "description": "Blend amount (0-1). Default is 0.5"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// mix: Blend two colors in perceptual space\n// Uses shortest hue path for natural color blending.\n//\n// Algorithm: Linear interpolation on L, C, and shortest-path H\n//\n// Input:  Any color space (converted to OKLCH internally)\n// Output: OKLCH (working space)\n// To get sRGB: mix(color1, color2, 0.5).to.srgb()\n\nvariable input: List = {input};\nvariable color1: Color.OKLCH = input.get(0).to.oklch();\nvariable color2: Color.OKLCH = input.get(1).to.oklch();\n\n// Default amount is 0.5 (50/50 blend)\nvariable amount: Number = 0.5;\nif (input.length() > 2) [\n    amount = input.get(2);\n];\n\n// Interpolate lightness and chroma linearly\nvariable new_l: Number = color1.l + (color2.l - color1.l) * amount;\nvariable new_c: Number = color1.c + (color2.c - color1.c) * amount;\n\n// Interpolate hue using shortest path\nvariable h1: Number = color1.h;\nvariable h2: Number = color2.h;\nvariable h_diff: Number = h2 - h1;\n\n// Normalize to shortest path (-180 to 180)\nif (h_diff > 180) [ h_diff = h_diff - 360; ];\nif (h_diff < -180) [ h_diff = h_diff + 360; ];\n\nvariable new_h: Number = h1 + h_diff * amount;\nif (new_h < 0) [ new_h = new_h + 360; ];\nif (new_h >= 360) [ new_h = new_h - 360; ];\n\n// Create mixed color\nvariable result: Color.OKLCH;\nresult.l = new_l;\nresult.c = new_c;\nresult.h = new_h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "mix"
-    },
-    {
-      "name": "Monochromatic",
-      "type": "function",
-      "description": "Generates a monochromatic color palette - variations of a single hue with different lightness and chroma. Useful for creating cohesive single-color schemes. Preserves hue, varies lightness from light to dark.",
-      "keyword": "monochromatic",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of colors to generate (default: 5)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Monochromatic Color Palette\n// Generates variations of a single hue with different lightness\n//\n// A monochromatic scheme uses:\n// - Same hue throughout\n// - Varying lightness (from light tints to dark shades)\n// - Varying chroma (reduced at extremes for natural appearance)\n//\n// This creates harmonious, cohesive palettes ideal for:\n// - UI background/foreground variations\n// - Data visualization with single-variable emphasis\n// - Brand color systems\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\n// Default count is 5\nvariable count: Number = 5;\nif (input.length() > 1) [\n    count = input.get(1);\n];\n\n// Preserve the hue\nvariable base_h: Number = base.h;\nvariable base_c: Number = base.c;\n\n// Define lightness range (from light to dark)\nvariable light_start: Number = 0.9;\nvariable light_end: Number = 0.3;\n\nvariable result: List;\nvariable i: Number = 0;\nvariable t: Number = 0;\nvariable step_l: Number = 0;\nvariable l_factor: Number = 0;\nvariable step_c: Number = 0;\nvariable color: Color.OKLCH;\n\nwhile (i < count) [\n    // Calculate interpolation factor\n    if (count > 1) [\n        t = i / (count - 1);\n    ] else [\n        t = 0.5;\n    ];\n    \n    // Interpolate lightness\n    step_l = light_start + (light_end - light_start) * t;\n    \n    // Scale chroma - reduce at extremes for natural appearance\n    // Peak chroma around middle lightness (0.6)\n    l_factor = step_l - 0.6;\n    if (l_factor < 0) [ l_factor = 0 - l_factor; ];\n    l_factor = 1 - l_factor * 1.5;\n    if (l_factor < 0.3) [ l_factor = 0.3; ];\n    if (l_factor > 1) [ l_factor = 1; ];\n    \n    step_c = base_c * l_factor;\n    \n    // Clamp chroma to avoid out-of-gamut\n    if (step_c > 0.35) [ step_c = 0.35; ];\n    \n    color.l = step_l;\n    color.c = step_c;\n    color.h = base_h;\n    \n    result = result, color.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "monochromatic"
-    },
-    {
-      "name": "muted",
-      "type": "function",
-      "description": "Decreases a color's chroma toward neutral (gray). Preserves lightness and hue while reducing colorfulness. The optional amount parameter controls the intensity (0-1, default 0.5). Uses OKLCH for perceptually uniform chroma adjustment. Useful for creating subtle backgrounds, disabled states, or calming variations of vibrant colors.",
-      "keyword": "muted",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to mute",
-                "type": "color"
-              },
-              {
-                "description": "Amount (0-1, default 0.5). Higher = more muted.",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "More muted version of the color"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// muted: Decrease chroma toward neutral (gray)\n// Preserves lightness and hue\n// Amount controls how much to reduce (0-1, 1 = fully gray)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Default amount\nvariable amount: Number = 0.5;\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Move chroma toward 0 by the specified amount\nvariable current_c: Number = color.c;\nvariable new_c: Number = current_c * (1 - amount);\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Mute vibrant red",
-          "input": [
-            "#ff0000"
-          ],
-          "output": "Desaturated red"
-        },
-        {
-          "description": "Fully muted becomes gray",
-          "input": [
-            "#ff0000",
-            1
-          ],
-          "output": "Gray with same lightness as red"
-        }
-      ],
-      "slug": "muted"
-    },
-    {
-      "name": "neutral_variant",
-      "type": "function",
-      "description": "Creates a neutral (gray) variant of a color while preserving its lightness. Optionally retains a hint of the original hue. Useful for creating subtle backgrounds, disabled states, or neutral UI elements that relate to a brand color. Uses OKLCH for accurate lightness preservation.",
-      "keyword": "neutral_variant",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Source color",
-                "type": "color"
-              },
-              {
-                "description": "Optional chroma retention (0-1, default 0 for pure gray)",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Neutral variant with same lightness"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// neutral_variant: Create gray version of color preserving lightness\n// Optionally retain some chroma for subtle tinting\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Default to pure gray (0 chroma retention)\nvariable retention: Number = 0;\nif (input.length() > 1) [\n    retention = input.get(1);\n];\n\n// Calculate retained chroma\nvariable new_c: Number = color.c * retention;\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;  // Hue preserved for subtle tinting\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Pure gray from blue",
-          "input": [
-            "#0066cc"
-          ],
-          "output": "Gray with same lightness as blue"
-        },
-        {
-          "description": "Slightly tinted gray",
-          "input": [
-            "#ff0000",
-            0.02
-          ],
-          "output": "Very subtle warm gray"
-        }
-      ],
-      "slug": "neutral_variant"
-    },
-    {
-      "name": "relative_luminance",
-      "type": "function",
-      "description": "Returns the WCAG 2.1 relative luminance of a color. This is the Y value from the XYZ-D65 color space, ranging from 0 (black) to 1 (white). Used in contrast ratio calculations. Different from perceptual lightness - relative luminance is weighted toward green (which human eyes are most sensitive to). Essential for WCAG accessibility calculations.",
-      "keyword": "relative_luminance",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to measure",
-                "type": "color"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 1
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "number",
-        "description": "Relative luminance (0-1)"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// relative_luminance: Get WCAG 2.1 relative luminance\n// Reference: WCAG 2.1 Definition of Relative Luminance\n// Reference: https://www.w3.org/TR/WCAG21/#dfn-relative-luminance\n//\n// Returns the Y component from CIE XYZ D65, which is the\n// relative luminance as defined by WCAG. Range is [0, 1]\n// where 0 = black and 1 = reference white.\n//\n// This value is used in WCAG contrast ratio calculations.\n\nvariable input: List = {input};\nvariable color: Color.XYZD65 = input.get(0).to.xyzd65();\n\nreturn color.y;"
-      },
-      "examples": [
-        {
-          "description": "White has luminance 1",
-          "input": [
-            "#ffffff"
-          ],
-          "output": 1
-        },
-        {
-          "description": "Black has luminance 0",
-          "input": [
-            "#000000"
-          ],
-          "output": 0
-        },
-        {
-          "description": "Pure green is brighter than pure blue",
-          "input": [
-            "#00ff00"
-          ],
-          "output": 0.7152
-        }
-      ],
-      "slug": "relative_luminance"
-    },
-    {
-      "name": "Rotate Hue",
-      "type": "function",
-      "description": "Rotates a color's hue by a specified number of degrees in OKLCH space. Positive values rotate clockwise, negative counterclockwise.",
-      "keyword": "rotate_hue",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to rotate"
-          },
-          "degrees": {
-            "type": "number",
-            "description": "Degrees to rotate (-360 to 360)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Rotate a color's hue by specified degrees\n// Preserves lightness and chroma\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable degrees: Number = input.get(1);\n\nvariable new_h: Number = color.h + degrees;\n\n// Normalize to 0-360\nwhile (new_h >= 360) [ new_h = new_h - 360; ];\nwhile (new_h < 0) [ new_h = new_h + 360; ];\n\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = new_h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "rotate_hue"
-    },
-    {
-      "name": "Saturate",
-      "type": "function",
-      "description": "Increases color saturation by boosting chroma in OKLCH space. Amount is 0-1 where 0.25 = 25% more saturated.",
-      "keyword": "saturate",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to saturate"
-          },
-          "amount": {
-            "type": "number",
-            "description": "Amount to saturate (0-1). Default is 0.25"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Saturate a color by increasing its OKLCH chroma\n// Amount: 0-1 where 0.25 means 25% increase\n//\n// Algorithm: C' = C * (1 + amount)\n// Chroma has no strict upper bound but ~0.4 is practical max for sRGB\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Default amount is 0.25 (25%)\nvariable amount: Number = 0.25;\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Calculate new chroma\nvariable current_c: Number = color.c;\nvariable new_c: Number = current_c * (1 + amount);\n\n// Soft clamp at 0.4 (approximate sRGB gamut max)\nif (new_c > 0.4) [ new_c = 0.4; ];\n\n// Create output in OKLCH, return as sRGB\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "saturate"
-    },
-    {
-      "name": "scale_chroma",
-      "type": "function",
-      "description": "Scales a color's chroma (saturation) by a factor. Unlike set_chroma which sets an absolute value, scale_chroma multiplies the current chroma. A factor of 1.5 increases colorfulness by 50%, while 0.5 decreases it by 50%. Uses OKLCH for perceptually uniform scaling. Useful for creating more or less vivid versions of a color.",
-      "keyword": "scale_chroma",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to scale",
-                "type": "color"
-              },
-              {
-                "description": "Scale factor (e.g., 1.5 for +50%, 0.5 for -50%)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with scaled chroma"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// scale_chroma: Multiply chroma by a factor\n// Uses OKLCH for perceptually uniform scaling\n// Chroma cannot be negative; clamps to 0\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable factor: Number = input.get(1);\n\n// Scale chroma\nvariable new_c: Number = color.c * factor;\n\n// Clamp to valid range (no negative chroma)\nif (new_c < 0) [ new_c = 0; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Make color more vivid",
-          "input": [
-            "#cc8080",
-            1.5
-          ],
-          "output": "More saturated red"
-        },
-        {
-          "description": "Desaturate color",
-          "input": [
-            "#ff0000",
-            0.5
-          ],
-          "output": "Muted red"
-        }
-      ],
-      "slug": "scale_chroma"
-    },
-    {
-      "name": "scale_lightness",
-      "type": "function",
-      "description": "Scales a color's lightness by a factor. Unlike set_lightness which sets an absolute value, scale_lightness multiplies the current lightness. A factor of 1.2 increases lightness by 20%, while 0.8 decreases it by 20%. Uses OKLCH for perceptually uniform scaling. Result is clamped to valid lightness range [0, 1].",
-      "keyword": "scale_lightness",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to scale",
-                "type": "color"
-              },
-              {
-                "description": "Scale factor (e.g., 1.2 for +20%, 0.8 for -20%)",
-                "type": "number"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with scaled lightness"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// scale_lightness: Multiply lightness by a factor\n// Uses OKLCH for perceptually uniform scaling\n// Clamps result to valid range [0, 1]\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable factor: Number = input.get(1);\n\n// Scale lightness\nvariable new_l: Number = color.l * factor;\n\n// Clamp to valid range\nif (new_l < 0) [ new_l = 0; ];\nif (new_l > 1) [ new_l = 1; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = new_l;\nresult.c = color.c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Brighten color by 20%",
-          "input": [
-            "#808080",
-            1.2
-          ],
-          "output": "Lighter gray"
-        },
-        {
-          "description": "Dim color by 50%",
-          "input": [
-            "#ffffff",
-            0.5
-          ],
-          "output": "Mid-gray"
-        }
-      ],
-      "slug": "scale_lightness"
-    },
-    {
-      "name": "sepia",
-      "type": "function",
-      "description": "Applies a sepia tone to a color, simulating the warm brownish tint of aged photographs. Uses the standard sepia matrix transformation. Amount parameter controls intensity from 0 (no effect) to 1 (full sepia).",
-      "keyword": "sepia",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to transform",
-                "type": "color"
-              },
-              {
-                "description": "Sepia intensity (0-1), default 1",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color with sepia tone applied"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// sepia: Apply sepia tone transformation\n// Reference: CSS Filter Effects Module Level 1\n// Reference: https://www.w3.org/TR/filter-effects-1/#sepiaEquivalent\n//\n// Uses the standard sepia matrix transformation as defined in CSS.\n// The amount parameter controls intensity (0 = no effect, 1 = full sepia).\n//\n// Matrix coefficients:\n//   R' = 0.393R + 0.769G + 0.189B\n//   G' = 0.349R + 0.686G + 0.168B\n//   B' = 0.272R + 0.534G + 0.131B\n\nvariable input: List = {input};\nvariable color: Color.SRGB = input.get(0).to.srgb();\nvariable amount: Number = 1;\n\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Clamp amount\nif (amount < 0) [ amount = 0; ];\nif (amount > 1) [ amount = 1; ];\n\nvariable r: Number = color.r;\nvariable g: Number = color.g;\nvariable b: Number = color.b;\n\n// Standard sepia matrix transformation (CSS filter spec)\n// R' = 0.393R + 0.769G + 0.189B\n// G' = 0.349R + 0.686G + 0.168B\n// B' = 0.272R + 0.534G + 0.131B\nvariable sepia_r: Number = (r * 0.393) + (g * 0.769) + (b * 0.189);\nvariable sepia_g: Number = (r * 0.349) + (g * 0.686) + (b * 0.168);\nvariable sepia_b: Number = (r * 0.272) + (g * 0.534) + (b * 0.131);\n\n// Clamp sepia values to valid range\nif (sepia_r > 1) [ sepia_r = 1; ];\nif (sepia_g > 1) [ sepia_g = 1; ];\nif (sepia_b > 1) [ sepia_b = 1; ];\n\n// Interpolate between original and sepia based on amount\nvariable new_r: Number = r + (sepia_r - r) * amount;\nvariable new_g: Number = g + (sepia_g - g) * amount;\nvariable new_b: Number = b + (sepia_b - b) * amount;\n\n// Create result\nvariable result: Color.SRGB;\nresult.r = new_r;\nresult.g = new_g;\nresult.b = new_b;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Full sepia",
-          "input": [
-            "#808080",
-            1
-          ],
-          "output": "Warm brownish gray"
-        },
-        {
-          "description": "Partial sepia",
-          "input": [
-            "#808080",
-            0.5
-          ],
-          "output": "Subtly warm gray"
-        }
-      ],
-      "slug": "sepia"
-    },
-    {
-      "name": "Set Chroma",
-      "type": "function",
-      "description": "Sets a color's chroma (saturation) to a specific value in OKLCH space. Preserves hue and lightness.",
-      "keyword": "set_chroma",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to modify"
-          },
-          "chroma": {
-            "type": "number",
-            "description": "Target chroma (0-0.4 typical for sRGB)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Set a color's chroma to a specific value\n// Preserves hue and lightness\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable target_c: Number = input.get(1);\n\n// Clamp to valid range (0 to ~0.4 for sRGB gamut)\nif (target_c < 0) [ target_c = 0; ];\nif (target_c > 0.4) [ target_c = 0.4; ];\n\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = target_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "set_chroma"
-    },
-    {
-      "name": "Set Hue",
-      "type": "function",
-      "description": "Sets a color's hue to a specific angle in OKLCH space. Preserves lightness and chroma.",
-      "keyword": "set_hue",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to modify"
-          },
-          "hue": {
-            "type": "number",
-            "description": "Target hue angle (0-360)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Set a color's hue to a specific angle\n// Preserves lightness and chroma\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable target_h: Number = input.get(1);\n\n// Normalize to 0-360\nwhile (target_h >= 360) [ target_h = target_h - 360; ];\nwhile (target_h < 0) [ target_h = target_h + 360; ];\n\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = target_h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "set_hue"
-    },
-    {
-      "name": "Set Lightness",
-      "type": "function",
-      "description": "Sets a color's lightness to a specific value in OKLCH space. Preserves hue and chroma.",
-      "keyword": "set_lightness",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "The color to modify"
-          },
-          "lightness": {
-            "type": "number",
-            "description": "Target lightness (0-1)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Set a color's lightness to a specific value\n// Preserves hue and chroma\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable target_l: Number = input.get(1);\n\n// Clamp to valid range\nif (target_l < 0) [ target_l = 0; ];\nif (target_l > 1) [ target_l = 1; ];\n\nvariable result: Color.OKLCH;\nresult.l = target_l;\nresult.c = color.c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "set_lightness"
-    },
-    {
-      "name": "Shade Scale",
-      "type": "function",
-      "description": "Generates a Tailwind/Material-style shade scale from 50 (lightest) to 900 (darkest). The input color becomes the 500 (middle) value. Perfect for design system color tokens.",
-      "keyword": "shade_scale",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color (becomes the 500 shade)"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of shades. Default is 10 (50-900)"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate a design system shade scale (like Tailwind 50-900)\n// Input color becomes the middle (500) shade\n//\n// Lightness distribution:\n//   50: ~0.97  (very light)\n//  100: ~0.93\n//  200: ~0.87\n//  300: ~0.78\n//  400: ~0.67\n//  500: input lightness (base)\n//  600: ~0.52\n//  700: ~0.42\n//  800: ~0.32\n//  900: ~0.22 (very dark)\n//\n// Chroma is scaled to avoid washed-out lights and muddy darks\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\nvariable count: Number = 10;\nif (input.length() > 1) [\n    count = input.get(1);\n];\n\n// Target lightness values for standard 10-step scale\n// These are perceptually optimized for OKLCH\nvariable lightness_targets: List = 0.97, 0.93, 0.87, 0.78, 0.67, 0.55, 0.45, 0.35, 0.27, 0.20;\n\nvariable base_h: Number = base.h;\nvariable base_c: Number = base.c;\n\nvariable result: List;\nvariable i: Number = 0;\nvariable target_l: Number = 0;\nvariable l_factor: Number = 0;\nvariable scaled_c: Number = 0;\nvariable shade: Color.OKLCH;\n\nwhile (i < count) [\n    target_l = lightness_targets.get(i);\n    \n    // Scale chroma based on lightness\n    // Chroma peaks in midtones, reduces at extremes\n    l_factor = 1 - abs(target_l - 0.55) * 1.2;\n    if (l_factor < 0.3) [ l_factor = 0.3; ];\n    if (l_factor > 1.2) [ l_factor = 1.2; ];\n    \n    scaled_c = base_c * l_factor;\n    if (scaled_c > 0.4) [ scaled_c = 0.4; ];\n    \n    shade.l = target_l;\n    shade.c = scaled_c;\n    shade.h = base_h;\n    \n    result = result, shade.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "shade_scale"
-    },
-    {
-      "name": "Split Complement",
-      "type": "function",
-      "description": "Generates split-complementary colors - base color plus two colors adjacent to its complement. More nuanced than direct complement, less tension than triadic.",
-      "keyword": "split_complement",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color"
-          },
-          "angle": {
-            "type": "number",
-            "description": "Degrees from complement for split colors. Default is 30"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate split-complementary colors\n// Returns [base, complement-angle, complement+angle]\n//\n// Use case: Balanced contrast with more variety than complement\n// Example: Blue → Orange-Red, Orange-Yellow (instead of just Orange)\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\nvariable angle: Number = 30;\nif (input.length() > 1) [\n    angle = input.get(1);\n];\n\nvariable complement_h: Number = base.h + 180;\nif (complement_h >= 360) [ complement_h = complement_h - 360; ];\n\nvariable result: List;\n\n// Base color\nresult = result, base.to.srgb();\n\n// Complement - angle\nvariable h2: Number = complement_h - angle;\nif (h2 < 0) [ h2 = h2 + 360; ];\nvariable c2: Color.OKLCH;\nc2.l = base.l; c2.c = base.c; c2.h = h2;\nresult = result, c2.to.srgb();\n\n// Complement + angle\nvariable h3: Number = complement_h + angle;\nif (h3 >= 360) [ h3 = h3 - 360; ];\nvariable c3: Color.OKLCH;\nc3.l = base.l; c3.c = base.c; c3.h = h3;\nresult = result, c3.to.srgb();\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "split_complement"
-    },
-    {
-      "name": "Steps",
-      "type": "function",
-      "description": "Generates a list of colors interpolated between two colors in OKLCH space. Perfect for gradient stops.",
-      "keyword": "steps",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color1": {
-            "type": "color",
-            "description": "Start color"
-          },
-          "color2": {
-            "type": "color",
-            "description": "End color"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of steps (including start and end). Default is 5"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate gradient steps between two colors in OKLCH space\n// Returns a List of colors from start to end (inclusive)\n//\n// Uses perceptually uniform interpolation with shortest hue path\n\nvariable input: List = {input};\nvariable color1: Color.OKLCH = input.get(0).to.oklch();\nvariable color2: Color.OKLCH = input.get(1).to.oklch();\n\n// Default count is 5\nvariable count: Number = 5;\nif (input.length() > 2) [\n    count = input.get(2);\n];\n\n// Calculate hue difference (shortest path)\nvariable h1: Number = color1.h;\nvariable h2: Number = color2.h;\nvariable h_diff: Number = h2 - h1;\nif (h_diff > 180) [ h_diff = h_diff - 360; ];\nif (h_diff < -180) [ h_diff = h_diff + 360; ];\n\n// Generate steps\nvariable result: List;\nvariable i: Number = 0;\nvariable t: Number = 0;\nvariable step_l: Number = 0;\nvariable step_c: Number = 0;\nvariable step_h: Number = 0;\nvariable step_color: Color.OKLCH;\n\nwhile (i < count) [\n    t = i / (count - 1);\n    \n    // Interpolate each component\n    step_l = color1.l + (color2.l - color1.l) * t;\n    step_c = color1.c + (color2.c - color1.c) * t;\n    step_h = h1 + h_diff * t;\n    \n    // Normalize hue\n    if (step_h < 0) [ step_h = step_h + 360; ];\n    if (step_h >= 360) [ step_h = step_h - 360; ];\n    \n    // Create color and add to list\n    step_color.l = step_l;\n    step_color.c = step_c;\n    step_color.h = step_h;\n    \n    result = result, step_color.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "steps"
-    },
-    {
-      "name": "Tetradic",
-      "type": "function",
-      "description": "Generates tetradic (square) colors - four hues equally spaced 90° apart. Creates rich, complex palettes with two complementary pairs.",
-      "keyword": "tetradic",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate tetradic (square) colors (90° apart)\n// Returns [base, base+90°, base+180°, base+270°]\n//\n// Use case: Rich, complex palettes\n// Contains two complementary pairs\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\nvariable result: List;\n\n// Base color (0°)\nresult = result, base.to.srgb();\n\n// +90°\nvariable h2: Number = base.h + 90;\nif (h2 >= 360) [ h2 = h2 - 360; ];\nvariable c2: Color.OKLCH;\nc2.l = base.l; c2.c = base.c; c2.h = h2;\nresult = result, c2.to.srgb();\n\n// +180° (complement)\nvariable h3: Number = base.h + 180;\nif (h3 >= 360) [ h3 = h3 - 360; ];\nvariable c3: Color.OKLCH;\nc3.l = base.l; c3.c = base.c; c3.h = h3;\nresult = result, c3.to.srgb();\n\n// +270°\nvariable h4: Number = base.h + 270;\nif (h4 >= 360) [ h4 = h4 - 360; ];\nvariable c4: Color.OKLCH;\nc4.l = base.l; c4.c = base.c; c4.h = h4;\nresult = result, c4.to.srgb();\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "tetradic"
-    },
-    {
-      "name": "Tint Scale",
-      "type": "function",
-      "description": "Creates a sequential scale of tints from a base color. Varies lightness while preserving hue and adjusting chroma proportionally. Perfect for sequential/quantitative data visualization.",
-      "keyword": "tint_scale",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color for the scale"
-          },
-          "count": {
-            "type": "number",
-            "description": "Number of tints to generate. Default is 9"
-          },
-          "light_start": {
-            "type": "number",
-            "description": "Lightness of lightest tint (0-1). Default is 0.95"
-          },
-          "light_end": {
-            "type": "number",
-            "description": "Lightness of darkest tint (0-1). Default is 0.25"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Create a sequential tint scale from a base color\n// Varies lightness while preserving hue and scaling chroma\n//\n// Ideal for: choropleth maps, intensity scales, single-hue heatmaps\n// Chroma is scaled proportionally to maintain color harmony\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\n// Default count is 9\nvariable count: Number = 9;\nif (input.length() > 1) [\n    count = input.get(1);\n];\n\n// Default light_start is 0.95 (nearly white)\nvariable light_start: Number = 0.95;\nif (input.length() > 2) [\n    light_start = input.get(2);\n];\n\n// Default light_end is 0.25 (dark)\nvariable light_end: Number = 0.25;\nif (input.length() > 3) [\n    light_end = input.get(3);\n];\n\n// Base color properties\nvariable base_h: Number = base.h;\nvariable base_c: Number = base.c;\nvariable base_l: Number = base.l;\n\n// Calculate chroma scaling factor (chroma decreases at extreme lightness)\nvariable max_c: Number = base_c * 1.2;\n\nvariable result: List;\nvariable i: Number = 0;\nvariable t: Number = 0;\nvariable step_l: Number = 0;\nvariable l_dist: Number = 0;\nvariable chroma_scale: Number = 0;\nvariable step_c: Number = 0;\nvariable color: Color.OKLCH;\n\nwhile (i < count) [\n    t = i / (count - 1);\n    \n    // Interpolate lightness\n    step_l = light_start + (light_end - light_start) * t;\n    \n    // Scale chroma based on lightness distance from optimal (~0.6)\n    // Chroma is highest in midtones, lower at extremes\n    l_dist = step_l - 0.6;\n    if (l_dist < 0) [ l_dist = 0 - l_dist; ];\n    chroma_scale = 1 - l_dist * 1.5;\n    if (chroma_scale < 0.1) [ chroma_scale = 0.1; ];\n    step_c = max_c * chroma_scale;\n    \n    // Clamp chroma\n    if (step_c > 0.4) [ step_c = 0.4; ];\n    \n    color.l = step_l;\n    color.c = step_c;\n    color.h = base_h;\n    \n    result = result, color.to.srgb();\n    i = i + 1;\n];\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "tint_scale"
-    },
-    {
-      "name": "to_gamut",
-      "type": "function",
-      "description": "Maps a color into a target gamut using the CSS Color Level 4 gamut mapping algorithm. This preserves the perceptual lightness and hue while reducing chroma until the color fits within the target color space. Uses OKLCH for perceptually uniform mapping and binary search with Delta E OK for convergence. Essential for wide-gamut to sRGB conversion in design systems.",
-      "keyword": "to_gamut",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to map into gamut",
-                "type": "color"
-              },
-              {
-                "description": "Target gamut/space (default 'srgb')",
-                "type": "string"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color mapped into the target gamut"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// to_gamut: Perceptual gamut mapping (CSS Color Level 4 algorithm)\n// Reference: CSS Color Level 4, Section 13.2 Gamut Mapping\n// Reference: https://www.w3.org/TR/css-color-4/#gamut-mapping\n//\n// Maps out-of-gamut colors into sRGB while preserving perceptual\n// intent. Uses OKLCH space with binary search on chroma:\n//   - Lightness and hue are preserved\n//   - Chroma is reduced until the color fits in gamut\n//\n// This is the CSS Gamut Mapping Algorithm (GMA) used by browsers.\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Target space (default sRGB) - currently only supports sRGB\nvariable target_space: String = \"srgb\";\nif (input.length() > 1) [\n    target_space = input.get(1);\n];\n\n// Constants\nvariable epsilon: Number = 0.0001;\nvariable neg_epsilon: Number = 0 - epsilon;\nvariable one_plus_eps: Number = 1 + epsilon;\n\n// Check if already in gamut by converting and checking bounds\nvariable test_color: Color.SRGB = color.to.srgb();\nvariable in_gamut: Boolean = true;\n\n// Check if sRGB values are in range [0, 1]\nif (test_color.r < neg_epsilon) [ in_gamut = false; ];\nif (test_color.r > one_plus_eps) [ in_gamut = false; ];\nif (test_color.g < neg_epsilon) [ in_gamut = false; ];\nif (test_color.g > one_plus_eps) [ in_gamut = false; ];\nif (test_color.b < neg_epsilon) [ in_gamut = false; ];\nif (test_color.b > one_plus_eps) [ in_gamut = false; ];\n\n// If already in gamut, return clamped version\nif (in_gamut) [\n    variable clamped: Color.SRGB;\n    clamped.r = min(1, max(0, test_color.r));\n    clamped.g = min(1, max(0, test_color.g));\n    clamped.b = min(1, max(0, test_color.b));\n    return clamped;\n];\n\n// Binary search: reduce chroma until in gamut\nvariable min_c: Number = 0;\nvariable max_c: Number = color.c;\nvariable current: Color.OKLCH;\ncurrent.l = color.l;\ncurrent.h = color.h;\n\nvariable iterations: Number = 0;\nvariable max_iterations: Number = 25;\n\nwhile (max_c - min_c > epsilon) [\n    if (iterations >= max_iterations) [\n        max_c = min_c;  // Force exit\n    ];\n    \n    variable mid_c: Number = (min_c + max_c) / 2;\n    current.c = mid_c;\n    \n    variable test: Color.SRGB = current.to.srgb();\n    variable test_in_gamut: Boolean = true;\n    \n    if (test.r < neg_epsilon) [ test_in_gamut = false; ];\n    if (test.r > one_plus_eps) [ test_in_gamut = false; ];\n    if (test.g < neg_epsilon) [ test_in_gamut = false; ];\n    if (test.g > one_plus_eps) [ test_in_gamut = false; ];\n    if (test.b < neg_epsilon) [ test_in_gamut = false; ];\n    if (test.b > one_plus_eps) [ test_in_gamut = false; ];\n    \n    if (test_in_gamut) [\n        // We can try higher chroma\n        min_c = mid_c;\n    ] else [\n        // Need to reduce chroma\n        max_c = mid_c;\n    ];\n    \n    iterations = iterations + 1;\n];\n\n// Use the last valid chroma\ncurrent.c = min_c;\nvariable result: Color.SRGB = current.to.srgb();\n\n// Final clamp for any floating point errors\nvariable final_result: Color.SRGB;\nfinal_result.r = min(1, max(0, result.r));\nfinal_result.g = min(1, max(0, result.g));\nfinal_result.b = min(1, max(0, result.b));\n\nreturn final_result;"
-      },
-      "examples": [
-        {
-          "description": "Map out-of-gamut P3 color to sRGB",
-          "input": [
-            "oklch(0.8 0.3 150)",
-            "srgb"
-          ],
-          "output": "Color with reduced chroma that fits sRGB"
-        },
-        {
-          "description": "In-gamut color returns unchanged",
-          "input": [
-            "#ff0000"
-          ],
-          "output": "#ff0000"
-        }
-      ],
-      "slug": "to_gamut"
-    },
-    {
-      "name": "Triadic",
-      "type": "function",
-      "description": "Generates triadic colors - three hues equally spaced 120° apart on the color wheel. Creates vibrant, balanced palettes with high contrast.",
-      "keyword": "triadic",
-      "input": {
-        "type": "object",
-        "properties": {
-          "color": {
-            "type": "color",
-            "description": "Base color"
-          }
-        }
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// Generate triadic colors (120° apart)\n// Returns [base, base+120°, base+240°]\n//\n// Use case: Vibrant, balanced palettes\n// Example: Red → Green → Blue\n\nvariable input: List = {input};\nvariable base: Color.OKLCH = input.get(0).to.oklch();\n\nvariable result: List;\n\n// Base color\nresult = result, base.to.srgb();\n\n// +120°\nvariable h2: Number = base.h + 120;\nif (h2 >= 360) [ h2 = h2 - 360; ];\nvariable c2: Color.OKLCH;\nc2.l = base.l; c2.c = base.c; c2.h = h2;\nresult = result, c2.to.srgb();\n\n// +240°\nvariable h3: Number = base.h + 240;\nif (h3 >= 360) [ h3 = h3 - 360; ];\nvariable c3: Color.OKLCH;\nc3.l = base.l; c3.c = base.c; c3.h = h3;\nresult = result, c3.to.srgb();\n\nreturn result;"
-      },
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/"
-      ],
-      "slug": "triadic"
-    },
-    {
-      "name": "vibrant",
-      "type": "function",
-      "description": "Increases a color's chroma toward a vibrant level. Preserves lightness and hue while boosting colorfulness. The optional amount parameter controls the intensity (0-1, default 0.5). Uses OKLCH for perceptually uniform chroma adjustment. Useful for creating attention-grabbing accents or active states from muted base colors.",
-      "keyword": "vibrant",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to make vibrant",
-                "type": "color"
-              },
-              {
-                "description": "Amount (0-1, default 0.5). Higher = more vibrant.",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "More vibrant version of the color"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// vibrant: Increase chroma toward maximum colorfulness\n// Preserves lightness and hue\n// Amount controls how much to boost (0-1)\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\n\n// Default amount\nvariable amount: Number = 0.5;\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Target maximum chroma for sRGB at this lightness (approximate)\n// Real max varies by hue and lightness, but 0.3 is a reasonable target\nvariable max_chroma: Number = 0.3;\n\n// Increase chroma toward max\nvariable current_c: Number = color.c;\nvariable new_c: Number = current_c + (max_chroma - current_c) * amount;\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = new_c;\nresult.h = color.h;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Make muted blue more vibrant",
-          "input": [
-            "#6688aa"
-          ],
-          "output": "More saturated blue"
-        },
-        {
-          "description": "Full vibrancy",
-          "input": [
-            "#808080",
-            1
-          ],
-          "output": "Still gray (no hue to enhance)"
-        }
-      ],
-      "slug": "vibrant"
-    },
-    {
-      "name": "warmer",
-      "type": "function",
-      "description": "Shifts a color's hue towards warm colors (orange, ~60° in OKLCH). The amount parameter controls how much to shift, from 0 (no change) to 1 (fully warm). Preserves lightness and chroma.",
-      "keyword": "warmer",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/oklch-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Color to warm",
-                "type": "color"
-              },
-              {
-                "description": "Amount to shift (0-1), default 0.25",
-                "type": "number"
-              }
-            ],
-            "minItems": 1,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "color",
-        "description": "Color shifted towards warm hues"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// warmer: Shift hue towards warm colors\n//\n// Warm colors are centered around orange (~60° in OKLCH).\n// The function interpolates the hue towards this target via\n// the shortest angular path on the hue wheel.\n//\n// Parameters:\n//   color  - Input color\n//   amount - Shift amount (0 = no change, 1 = fully warm), default 0.25\n//\n// Preserves lightness and chroma.\n\nvariable input: List = {input};\nvariable color: Color.OKLCH = input.get(0).to.oklch();\nvariable amount: Number = 0.25;\n\nif (input.length() > 1) [\n    amount = input.get(1);\n];\n\n// Warm hue target (orange in OKLCH is around 60°)\nvariable warm_hue: Number = 60;\n\n// Calculate shortest path hue difference\nvariable hue_diff: Number = warm_hue - color.h;\n\n// Wrap to shortest path\nif (hue_diff > 180) [ hue_diff = hue_diff - 360; ];\nif (hue_diff < -180) [ hue_diff = hue_diff + 360; ];\n\n// Apply interpolation\nvariable new_hue: Number = color.h + (hue_diff * amount);\n\n// Normalize to 0-360\nif (new_hue < 0) [ new_hue = new_hue + 360; ];\nif (new_hue >= 360) [ new_hue = new_hue - 360; ];\n\n// Create result\nvariable result: Color.OKLCH;\nresult.l = color.l;\nresult.c = color.c;\nresult.h = new_hue;\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Make blue warmer",
-          "input": [
-            "#0000ff",
-            0.5
-          ],
-          "output": "Blue shifted towards purple/magenta"
-        }
-      ],
-      "slug": "warmer"
-    },
-    {
-      "name": "wcag_level",
-      "type": "function",
-      "description": "Returns the WCAG 2.1 compliance level for a foreground/background color pair. Returns 'AAA' (ratio >= 7:1), 'AA' (ratio >= 4.5:1), 'AA-large' (ratio >= 3:1), or 'fail' (ratio < 3:1). Based on W3C WCAG 2.1 Success Criteria 1.4.3 and 1.4.6.",
-      "keyword": "wcag_level",
-      "requirements": [
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/srgb-color/0/",
-        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/xyz-d65-color/0/"
-      ],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": [
-              {
-                "description": "Foreground color (text)",
-                "type": "color"
-              },
-              {
-                "description": "Background color",
-                "type": "color"
-              }
-            ],
-            "minItems": 2,
-            "maxItems": 2
-          }
-        },
-        "required": [
-          "input"
-        ]
-      },
-      "returns": {
-        "type": "string",
-        "description": "WCAG level: 'AAA', 'AA', 'AA-large', or 'fail'"
-      },
-      "script": {
-        "type": "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
-        "script": "// wcag_level: Determine WCAG 2.1 compliance level for a color pair\n// Reference: WCAG 2.1 Success Criterion 1.4.3 (Contrast Minimum)\n// Reference: WCAG 2.1 Success Criterion 1.4.6 (Contrast Enhanced)\n// Reference: https://www.w3.org/TR/WCAG21/#contrast-minimum\n//\n// Returns one of:\n//   \"AAA\"      - Ratio >= 7:1 (enhanced contrast for normal text)\n//   \"AA\"       - Ratio >= 4.5:1 (minimum for normal text)\n//   \"AA-large\" - Ratio >= 3:1 (minimum for large text: 18pt or 14pt bold)\n//   \"fail\"     - Ratio < 3:1 (does not meet any criterion)\n\nvariable input: List = {input};\nvariable fg_xyz: Color.XYZD65 = input.get(0).to.xyzd65();\nvariable bg_xyz: Color.XYZD65 = input.get(1).to.xyzd65();\n\nvariable l1: Number = fg_xyz.y;\nvariable l2: Number = bg_xyz.y;\n\n// Ensure l1 is the lighter of the two\nif (l2 > l1) [\n    variable temp: Number = l1;\n    l1 = l2;\n    l2 = temp;\n];\n\n// Calculate contrast ratio per WCAG formula\n// Ratio = (L1 + 0.05) / (L2 + 0.05)\nvariable ratio: Number = (l1 + 0.05) / (l2 + 0.05);\n\n// Determine WCAG level\n// AAA: ratio >= 7:1 (enhanced contrast)\n// AA: ratio >= 4.5:1 (minimum for normal text)\n// AA-large: ratio >= 3:1 (minimum for large text, 18pt+ or 14pt+ bold)\n// fail: ratio < 3:1\n\nvariable result: String = \"fail\";\n\nif (ratio >= 7) [\n    result = \"AAA\";\n] else [\n    if (ratio >= 4.5) [\n        result = \"AA\";\n    ] else [\n        if (ratio >= 3) [\n            result = \"AA-large\";\n        ];\n    ];\n];\n\nreturn result;"
-      },
-      "examples": [
-        {
-          "description": "Black on white passes AAA",
-          "input": [
-            "#000000",
-            "#ffffff"
-          ],
-          "output": "AAA"
-        },
-        {
-          "description": "Gray on white may only pass AA-large",
-          "input": [
-            "#767676",
-            "#ffffff"
-          ],
-          "output": "AA"
-        }
-      ],
-      "slug": "wcag_level"
-    }
-  ],
-  "metadata": {
-    "generatedAt": "2026-01-07T09:20:35.633Z",
-    "totalSchemas": 82,
-    "generatedBy": "npx @tokens-studio/tokenscript-schemas bundle"
-  }
-}