@tokens-studio/tokenscript-schemas 0.0.11 → 0.0.13

package/src/schemas/types/srgb-linear-color/unit.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Linear sRGB Color Schema Tests
+ *
+ * Tests for the Linear sRGB color space (gamma-decoded)
+ * Validates against ColorJS for parity
+ */
+
+import { log } from "@tests/helpers/logger";
+import { executeWithSchema, getBundledSchema } from "@tests/helpers/schema-test-utils";
+import Color from "colorjs.io";
+import { describe, expect, it } from "vitest";
+import type { ColorSpecification } from "@/bundler/types";
+
+// ColorJS reference tolerance
+const TOLERANCE = 1e-9;
+
+describe("Linear sRGB Color Schema", () => {
+  describe("Schema Definition", () => {
+    it("should have correct schema structure", async () => {
+      const schema = (await getBundledSchema("srgb-linear-color")) as ColorSpecification;
+
+      expect(schema.name).toBe("LinearSRGB");
+      expect(schema.type).toBe("color");
+      expect(schema.schema).toBeDefined();
+      expect(schema.schema?.properties).toHaveProperty("r");
+      expect(schema.schema?.properties).toHaveProperty("g");
+      expect(schema.schema?.properties).toHaveProperty("b");
+      expect(schema.schema?.required).toEqual(["r", "g", "b"]);
+    });
+
+    it("should have linearsrgb initializer", async () => {
+      const schema = (await getBundledSchema("srgb-linear-color")) as ColorSpecification;
+
+      expect(schema.initializers).toHaveLength(1);
+      expect(schema.initializers[0].keyword).toBe("linearsrgb");
+      expect(schema.initializers[0].script.script).toContain("Color.LinearSRGB");
+    });
+
+    it("should have conversion from sRGB", async () => {
+      const schema = (await getBundledSchema("srgb-linear-color")) as ColorSpecification;
+
+      expect(schema.conversions.length).toBeGreaterThanOrEqual(1);
+
+      const srgbToLinear = schema.conversions.find((c: { source: string }) =>
+        c.source.includes("srgb-color"),
+      );
+      expect(srgbToLinear).toBeDefined();
+      expect(srgbToLinear?.lossless).toBe(true);
+    });
+  });
+
+  describe("Initialization", () => {
+    it("should create linear sRGB color from values", async () => {
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable c: Color.LinearSRGB;
+        c.r = 0.5;
+        c.g = 0.25;
+        c.b = 0.1;
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("LinearSRGB");
+      expect((result as any).value.r.value).toBeCloseTo(0.5, 10);
+      expect((result as any).value.g.value).toBeCloseTo(0.25, 10);
+      expect((result as any).value.b.value).toBeCloseTo(0.1, 10);
+    });
+  });
+
+  describe("Conversion from sRGB to Linear sRGB", () => {
+    it("should convert sRGB red to linear sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 1;
+        srgb.g = 0;
+        srgb.b = 0;
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("srgb", [1, 0, 0]).to("srgb-linear");
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("LinearSRGB");
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+
+    it("should convert mid-gray sRGB to linear (tests gamma curve)", async () => {
+      // Mid-gray (0.5) is a good test for the gamma curve
+      // Linear value should be ~0.214 (not 0.5!)
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 0.5;
+        srgb.g = 0.5;
+        srgb.b = 0.5;
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("srgb", [0.5, 0.5, 0.5]).to("srgb-linear");
+
+      log.info(`\n=== MID-GRAY Gamma Conversion ===`);
+      log.info(`Input sRGB:       { r: 0.5, g: 0.5, b: 0.5 }`);
+      log.info(
+        `TokenScript:      { r: ${(result as any).value.r.value}, g: ${(result as any).value.g.value}, b: ${(result as any).value.b.value} }`,
+      );
+      log.info(
+        `ColorJS:          { r: ${colorJS.coords[0]}, g: ${colorJS.coords[1]}, b: ${colorJS.coords[2]} }`,
+      );
+
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+
+    it("should handle linear region (sRGB ≤ 0.04045)", async () => {
+      // Test value below threshold - should use linear formula
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 0.03;
+        srgb.g = 0.03;
+        srgb.b = 0.03;
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("srgb", [0.03, 0.03, 0.03]).to("srgb-linear");
+
+      // Linear formula: 0.03 / 12.92 ≈ 0.00232
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+
+    it("should handle threshold boundary (0.04045)", async () => {
+      // Test exactly at threshold
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 0.04045;
+        srgb.g = 0.04045;
+        srgb.b = 0.04045;
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      const colorJS = new Color("srgb", [0.04045, 0.04045, 0.04045]).to("srgb-linear");
+
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 9);
+    });
+  });
+
+  describe("ColorJS Parity", () => {
+    const testCases = [
+      { name: "red", srgb: [1, 0, 0] },
+      { name: "green", srgb: [0, 1, 0] },
+      { name: "blue", srgb: [0, 0, 1] },
+      { name: "black", srgb: [0, 0, 0] },
+      { name: "white", srgb: [1, 1, 1] },
+      { name: "gray-50%", srgb: [0.5, 0.5, 0.5] },
+      { name: "gray-21.8%", srgb: [0.218, 0.218, 0.218] }, // Linear 0.04 approx
+      { name: "coral", srgb: [1, 0.341, 0.2] },
+      { name: "near-black", srgb: [0.01, 0.01, 0.01] },
+      { name: "near-white", srgb: [0.99, 0.99, 0.99] },
+    ];
+
+    for (const { name, srgb } of testCases) {
+      it(`should match ColorJS for ${name}`, async () => {
+        const result = await executeWithSchema(
+          "srgb-linear-color",
+          "type",
+          `
+          variable srgb: Color.SRGB;
+          srgb.r = ${srgb[0]};
+          srgb.g = ${srgb[1]};
+          srgb.b = ${srgb[2]};
+          srgb.to.linearsrgb()
+        `,
+        );
+
+        // ColorJS reference
+        const colorJS = new Color("srgb", srgb as [number, number, number]).to("srgb-linear");
+
+        const tsR = (result as any).value.r.value;
+        const tsG = (result as any).value.g.value;
+        const tsB = (result as any).value.b.value;
+
+        const diffR = Math.abs(tsR - colorJS.coords[0]);
+        const diffG = Math.abs(tsG - colorJS.coords[1]);
+        const diffB = Math.abs(tsB - colorJS.coords[2]);
+        const maxDiff = Math.max(diffR, diffG, diffB);
+
+        log.info(`\n=== ${name.toUpperCase()} ColorJS Parity ===`);
+        log.info(`Input sRGB:  { r: ${srgb[0]}, g: ${srgb[1]}, b: ${srgb[2]} }`);
+        log.info(
+          `TokenScript: { r: ${tsR.toFixed(9)}, g: ${tsG.toFixed(9)}, b: ${tsB.toFixed(9)} }`,
+        );
+        log.info(
+          `ColorJS:     { r: ${colorJS.coords[0].toFixed(9)}, g: ${colorJS.coords[1].toFixed(9)}, b: ${colorJS.coords[2].toFixed(9)} }`,
+        );
+        log.info(`Max Diff:    ${maxDiff.toExponential(2)}`);
+        log.info(`Status:      ${maxDiff < TOLERANCE ? "✅ PASS" : "❌ FAIL"}`);
+
+        expect(maxDiff).toBeLessThan(TOLERANCE);
+      });
+    }
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle pure black (0, 0, 0)", async () => {
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 0;
+        srgb.g = 0;
+        srgb.b = 0;
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      expect((result as any).value.r.value).toBe(0);
+      expect((result as any).value.g.value).toBe(0);
+      expect((result as any).value.b.value).toBe(0);
+    });
+
+    it("should handle pure white (1, 1, 1)", async () => {
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 1;
+        srgb.g = 1;
+        srgb.b = 1;
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      expect((result as any).value.r.value).toBeCloseTo(1, 9);
+      expect((result as any).value.g.value).toBeCloseTo(1, 9);
+      expect((result as any).value.b.value).toBeCloseTo(1, 9);
+    });
+  });
+
+  describe("Conversion Chain: RGB → sRGB → Linear sRGB", () => {
+    it("should convert RGB 255 through to linear sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-linear-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 255;
+        rgb.g = 128;
+        rgb.b = 64;
+        
+        variable srgb: Color.SRGB = rgb.to.srgb();
+        srgb.to.linearsrgb()
+      `,
+      );
+
+      // ColorJS reference: RGB → sRGB → Linear sRGB
+      const colorJS = new Color("srgb", [1, 128 / 255, 64 / 255]).to("srgb-linear");
+
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+  });
+});

package/src/schemas/types/xyz-d50-color/from-xyz-d65.tokenscript

@@ -0,0 +1,36 @@
+// XYZ-D65 to XYZ-D50 Conversion
+// Chromatic adaptation using Bradford transform
+// Reference: https://github.com/color-js/color.js/blob/main/src/adapt.js
+//
+// Bradford CAT matrix for D65 → D50:
+// [1.0479298   0.0229469  -0.0501923]
+// [0.0296278   0.9904344  -0.0170738]
+// [-0.0092430  0.0150552   0.7518743]
+//
+// Input: Color.XYZD65 with x, y, z tristimulus (D65 white)
+// Output: Color.XYZD50 with x, y, z tristimulus (D50 white)
+
+// Get input XYZ-D65 values
+variable x65: Number = {input}.x;
+variable y65: Number = {input}.y;
+variable z65: Number = {input}.z;
+
+// Bradford chromatic adaptation matrix (ColorJS exact values)
+// Row 1
+variable x50: Number = x65 * 1.0479297925449969 + y65 * 0.022946870601609652 + z65 * -0.05019226628920524;
+// Row 2
+variable y50: Number = x65 * 0.02962780877005599 + y65 * 0.9904344267538799 + z65 * -0.017073799063418826;
+// Row 3
+variable z50: Number = x65 * -0.009243040646204504 + y65 * 0.015055191490298152 + z65 * 0.7518742814281371;
+
+// Create output
+variable output: Color.XYZD50;
+output.x = x50;
+output.y = y50;
+output.z = z50;
+
+return output;
+
+
+
+

package/src/schemas/types/xyz-d50-color/initializer.tokenscript

@@ -0,0 +1,16 @@
+// XYZ-D50 Color Initializer
+// Creates an XYZ-D50 color from tristimulus values
+// Input: List of [x, y, z] tristimulus values
+
+variable xyz_values: List = {input};
+variable output: Color.XYZD50;
+
+output.x = xyz_values.get(0);
+output.y = xyz_values.get(1);
+output.z = xyz_values.get(2);
+
+return output;
+
+
+
+

package/src/schemas/types/xyz-d50-color/schema.json

@@ -0,0 +1,48 @@
+{
+  "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": "/api/v1/core/tokenscript/0/",
+        "script": "./initializer.tokenscript"
+      }
+    }
+  ],
+  "conversions": [
+    {
+      "source": "/api/v1/core/xyz-d65-color/0/",
+      "target": "$self",
+      "description": "Converts XYZ-D65 to XYZ-D50 using Bradford chromatic adaptation",
+      "lossless": true,
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./from-xyz-d65.tokenscript"
+      }
+    }
+  ]
+}

package/src/schemas/types/xyz-d50-color/unit.test.ts

@@ -0,0 +1,240 @@
+/**
+ * XYZ-D50 Color Schema Tests
+ *
+ * Tests for the CIE XYZ-D50 color space (D50 white point)
+ * Validates against ColorJS for parity
+ */
+
+import { log } from "@tests/helpers/logger";
+import { executeWithSchema, getBundledSchema } from "@tests/helpers/schema-test-utils";
+import Color from "colorjs.io";
+import { describe, expect, it } from "vitest";
+import type { ColorSpecification } from "@/bundler/types";
+
+// ColorJS reference tolerance
+const TOLERANCE = 1e-9;
+
+describe("XYZ-D50 Color Schema", () => {
+  describe("Schema Definition", () => {
+    it("should have correct schema structure", async () => {
+      const schema = (await getBundledSchema("xyz-d50-color")) as ColorSpecification;
+
+      expect(schema.name).toBe("XYZD50");
+      expect(schema.type).toBe("color");
+      expect(schema.schema).toBeDefined();
+      expect(schema.schema?.properties).toHaveProperty("x");
+      expect(schema.schema?.properties).toHaveProperty("y");
+      expect(schema.schema?.properties).toHaveProperty("z");
+      expect(schema.schema?.required).toEqual(["x", "y", "z"]);
+    });
+
+    it("should have xyzd50 initializer", async () => {
+      const schema = (await getBundledSchema("xyz-d50-color")) as ColorSpecification;
+
+      expect(schema.initializers).toHaveLength(1);
+      expect(schema.initializers[0].keyword).toBe("xyzd50");
+    });
+
+    it("should have conversion from XYZ-D65", async () => {
+      const schema = (await getBundledSchema("xyz-d50-color")) as ColorSpecification;
+
+      expect(schema.conversions).toHaveLength(1);
+
+      const d65ToD50 = schema.conversions.find((c: { source: string }) =>
+        c.source.includes("xyz-d65-color"),
+      );
+      expect(d65ToD50).toBeDefined();
+      expect(d65ToD50?.lossless).toBe(true);
+    });
+  });
+
+  describe("Initialization", () => {
+    it("should create XYZ-D50 color from values", async () => {
+      const result = await executeWithSchema(
+        "xyz-d50-color",
+        "type",
+        `
+        variable c: Color.XYZD50;
+        c.x = 0.5;
+        c.y = 0.4;
+        c.z = 0.3;
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("XYZD50");
+      expect((result as any).value.x.value).toBeCloseTo(0.5, 10);
+      expect((result as any).value.y.value).toBeCloseTo(0.4, 10);
+      expect((result as any).value.z.value).toBeCloseTo(0.3, 10);
+    });
+  });
+
+  describe("Chromatic Adaptation: XYZ-D65 to XYZ-D50", () => {
+    it("should convert D65 white point to D50 white point", async () => {
+      // D65 white point
+      const result = await executeWithSchema(
+        "xyz-d50-color",
+        "type",
+        `
+        variable xyz65: Color.XYZD65;
+        xyz65.x = 0.95047;
+        xyz65.y = 1.0;
+        xyz65.z = 1.08883;
+        xyz65.to.xyzd50()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("xyz-d65", [0.95047, 1.0, 1.08883]).to("xyz-d50");
+
+      log.info(`\n=== D65 White → D50 ===`);
+      log.info(`Input D65:   { x: 0.95047, y: 1.0, z: 1.08883 }`);
+      log.info(
+        `TokenScript: { x: ${(result as any).value.x.value}, y: ${(result as any).value.y.value}, z: ${(result as any).value.z.value} }`,
+      );
+      log.info(
+        `ColorJS:     { x: ${colorJS.coords[0]}, y: ${colorJS.coords[1]}, z: ${colorJS.coords[2]} }`,
+      );
+
+      expect((result as any).value.x.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.y.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.z.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+
+    it("should convert red XYZ-D65 to XYZ-D50", async () => {
+      // Red in XYZ-D65
+      const colorJSRed = new Color("srgb", [1, 0, 0]).to("xyz-d65");
+
+      const result = await executeWithSchema(
+        "xyz-d50-color",
+        "type",
+        `
+        variable xyz65: Color.XYZD65;
+        xyz65.x = ${colorJSRed.coords[0]};
+        xyz65.y = ${colorJSRed.coords[1]};
+        xyz65.z = ${colorJSRed.coords[2]};
+        xyz65.to.xyzd50()
+      `,
+      );
+
+      const colorJS = new Color("srgb", [1, 0, 0]).to("xyz-d50");
+
+      expect((result as any).value.x.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.y.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.z.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+  });
+
+  describe("Full Conversion Chain: sRGB → Linear → XYZ-D65 → XYZ-D50", () => {
+    it("should convert sRGB red through to XYZ-D50", async () => {
+      const result = await executeWithSchema(
+        "xyz-d50-color",
+        "type",
+        `
+        variable srgb: Color.SRGB;
+        srgb.r = 1;
+        srgb.g = 0;
+        srgb.b = 0;
+        
+        variable linear: Color.LinearSRGB = srgb.to.linearsrgb();
+        variable xyz65: Color.XYZD65 = linear.to.xyzd65();
+        xyz65.to.xyzd50()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("srgb", [1, 0, 0]).to("xyz-d50");
+
+      log.info(`\n=== sRGB RED → XYZ-D50 (full chain) ===`);
+      log.info(
+        `TokenScript: { x: ${(result as any).value.x.value}, y: ${(result as any).value.y.value}, z: ${(result as any).value.z.value} }`,
+      );
+      log.info(
+        `ColorJS:     { x: ${colorJS.coords[0]}, y: ${colorJS.coords[1]}, z: ${colorJS.coords[2]} }`,
+      );
+
+      expect((result as any).value.x.value).toBeCloseTo(colorJS.coords[0], 9);
+      expect((result as any).value.y.value).toBeCloseTo(colorJS.coords[1], 9);
+      expect((result as any).value.z.value).toBeCloseTo(colorJS.coords[2], 9);
+    });
+  });
+
+  describe("ColorJS Parity", () => {
+    const testCases = [
+      { name: "red", srgb: [1, 0, 0] },
+      { name: "green", srgb: [0, 1, 0] },
+      { name: "blue", srgb: [0, 0, 1] },
+      { name: "white", srgb: [1, 1, 1] },
+      { name: "black", srgb: [0, 0, 0] },
+      { name: "gray-50%", srgb: [0.5, 0.5, 0.5] },
+      { name: "cyan", srgb: [0, 1, 1] },
+      { name: "magenta", srgb: [1, 0, 1] },
+      { name: "yellow", srgb: [1, 1, 0] },
+    ];
+
+    for (const { name, srgb } of testCases) {
+      it(`should match ColorJS for ${name}`, async () => {
+        const result = await executeWithSchema(
+          "xyz-d50-color",
+          "type",
+          `
+          variable srgb: Color.SRGB;
+          srgb.r = ${srgb[0]};
+          srgb.g = ${srgb[1]};
+          srgb.b = ${srgb[2]};
+          
+          variable linear: Color.LinearSRGB = srgb.to.linearsrgb();
+          variable xyz65: Color.XYZD65 = linear.to.xyzd65();
+          xyz65.to.xyzd50()
+        `,
+        );
+
+        // ColorJS reference
+        const colorJS = new Color("srgb", srgb as [number, number, number]).to("xyz-d50");
+
+        const tsX = (result as any).value.x.value;
+        const tsY = (result as any).value.y.value;
+        const tsZ = (result as any).value.z.value;
+
+        const diffX = Math.abs(tsX - colorJS.coords[0]);
+        const diffY = Math.abs(tsY - colorJS.coords[1]);
+        const diffZ = Math.abs(tsZ - colorJS.coords[2]);
+        const maxDiff = Math.max(diffX, diffY, diffZ);
+
+        log.info(`\n=== ${name.toUpperCase()} ColorJS Parity ===`);
+        log.info(`Input sRGB:  { r: ${srgb[0]}, g: ${srgb[1]}, b: ${srgb[2]} }`);
+        log.info(
+          `TokenScript: { x: ${tsX.toFixed(9)}, y: ${tsY.toFixed(9)}, z: ${tsZ.toFixed(9)} }`,
+        );
+        log.info(
+          `ColorJS:     { x: ${colorJS.coords[0].toFixed(9)}, y: ${colorJS.coords[1].toFixed(9)}, z: ${colorJS.coords[2].toFixed(9)} }`,
+        );
+        log.info(`Max Diff:    ${maxDiff.toExponential(2)}`);
+        log.info(`Status:      ${maxDiff < TOLERANCE ? "✅ PASS" : "❌ FAIL"}`);
+
+        expect(maxDiff).toBeLessThan(TOLERANCE);
+      });
+    }
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle black (0, 0, 0)", async () => {
+      const result = await executeWithSchema(
+        "xyz-d50-color",
+        "type",
+        `
+        variable xyz65: Color.XYZD65;
+        xyz65.x = 0;
+        xyz65.y = 0;
+        xyz65.z = 0;
+        xyz65.to.xyzd50()
+      `,
+      );
+
+      expect((result as any).value.x.value).toBe(0);
+      expect((result as any).value.y.value).toBe(0);
+      expect((result as any).value.z.value).toBe(0);
+    });
+  });
+});

package/src/schemas/types/xyz-d65-color/from-linear-p3.tokenscript

@@ -0,0 +1,47 @@
+// Linear P3 to XYZ-D65 Conversion
+// Converts linear Display-P3 RGB to CIE XYZ (D65)
+// Reference: CSS Color Level 4 specification
+//
+// Uses the P3 to XYZ-D65 transformation matrix
+// Matrix values from ColorJS / CSS Color Level 4
+//
+// Input: Color.LinearP3 with linear r, g, b values
+// Output: Color.XYZD65 with x, y, z tristimulus values
+
+// Get linear P3 values
+variable r: Number = {input}.r;
+variable g: Number = {input}.g;
+variable b: Number = {input}.b;
+
+// Linear P3 to XYZ-D65 matrix
+// Row 1
+variable m00: Number = 0.4865709486482162;
+variable m01: Number = 0.26566769316909306;
+variable m02: Number = 0.1982172852343625;
+
+// Row 2
+variable m10: Number = 0.2289745640697488;
+variable m11: Number = 0.6917385218365064;
+variable m12: Number = 0.079286914093745;
+
+// Row 3
+variable m20: Number = 0.0;
+variable m21: Number = 0.04511338185890264;
+variable m22: Number = 1.043944368900976;
+
+// Matrix multiplication: [x, y, z] = M × [r, g, b]
+variable x: Number = m00 * r + m01 * g + m02 * b;
+variable y: Number = m10 * r + m11 * g + m12 * b;
+variable z: Number = m20 * r + m21 * g + m22 * b;
+
+// Create output
+variable output: Color.XYZD65;
+output.x = x;
+output.y = y;
+output.z = z;
+
+return output;
+
+
+
+